Gabriel_Sansigolo_Trabalho_de_DL_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# **Atividade - Uso de Redes Neurais Profundas**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## **Disciplina:** CAP-421-3 Aprendizado Profundo\n",
    "\n",
    "**Discintes:**\n",
    "\n",
    "Gabriel Sansigolo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### **Importando bibliotecas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import pandas as pd\n",
    "\n",
    "from torchinfo import summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Utiliza GPU (cuda), caso contrário, utiliza CPU**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *VGG19*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_dir = os.path.dirname(\"\")\n",
    "\n",
    "df_treinamento_vgg19 = pd.read_csv(os.path.join(path_dir, \"deep_learning/vgg19/treinamento_vgg19.csv\"), low_memory=False)\n",
    "df_treinamento_vgg19 = df_treinamento_vgg19.reset_index()  \n",
    "df_treinamento_vgg19=df_treinamento_vgg19.drop(df_treinamento_vgg19.index[:2])\n",
    "\n",
    "df_teste_vgg19 = pd.read_csv(os.path.join(path_dir, \"deep_learning/vgg19/teste_vgg19.csv\"), low_memory=False)\n",
    "df_teste_vgg19 = df_teste_vgg19.reset_index()  \n",
    "df_teste_vgg19=df_teste_vgg19.drop(df_teste_vgg19.index[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = []\n",
    "y_train = []\n",
    "X_test = []\n",
    "y_test = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 1 - Dividindo os dados (treinamento e teste)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df_treinamento_vgg19 = df_treinamento_vgg19.drop('category', axis=1)\n",
    "new_df_treinamento_vgg19 = new_df_treinamento_vgg19.astype(np.float32)\n",
    "X_train_tensor = torch.tensor(new_df_treinamento_vgg19.values)\n",
    "\n",
    "for row in df_treinamento_vgg19.itertuples(index=False, name='Pandas'):\n",
    "    y_train.append(0 if row.category == \"NaoPistas\" else 1)\n",
    "    \n",
    "new_df_teste_vgg19 = df_teste_vgg19.drop('category', axis=1)\n",
    "new_df_teste_vgg19 = new_df_teste_vgg19.astype(np.float32)\n",
    "X_test_tensor = torch.tensor(new_df_teste_vgg19.values)\n",
    "\n",
    "for row in df_teste_vgg19.itertuples(index=False, name='Pandas'):\n",
    "    y_test.append(0 if row.category == \"NaoPistas\" else 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_tensor = torch.tensor(y_train, device=device) \n",
    "y_test_tensor = torch.tensor(y_test,  device=device) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 2 - Verificação das Dimensões dos Dados de Treinamento e Teste**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([19622, 1001])\n",
      "torch.Size([19622])\n",
      "torch.Size([2465, 1001])\n",
      "torch.Size([2465])\n"
     ]
    }
   ],
   "source": [
    "print(X_train_tensor.shape)\n",
    "print(y_train_tensor.shape)\n",
    "print(X_test_tensor.shape)\n",
    "print(y_test_tensor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 3 - Definindo a Rede Neural Convolucional (CNN) para Classificação**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_timesteps, n_features, n_outputs = X_train_tensor.shape[0], X_train_tensor.shape[1], y_train_tensor.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvNet1D(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            nn.Conv1d(n_features, n_features, kernel_size=30),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.MaxPool1d(10))\n",
    "        self.layer2 = nn.Flatten()\n",
    "        self.layer3 = nn.Sequential(\n",
    "            nn.Linear(97,100),\n",
    "            nn.ReLU())\n",
    "        self.layer4 = nn.Sequential(\n",
    "            nn.Linear(100,2),\n",
    "            nn.Softmax(dim=1))\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ConvNet1D().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "=================================================================\n",
       "Layer (type:depth-idx)                   Param #\n",
       "=================================================================\n",
       "ConvNet1D                                --\n",
       "├─Sequential: 1-1                        --\n",
       "│    └─Conv1d: 2-1                       30,061,031\n",
       "│    └─ReLU: 2-2                         --\n",
       "│    └─Dropout: 2-3                      --\n",
       "│    └─MaxPool1d: 2-4                    --\n",
       "├─Flatten: 1-2                           --\n",
       "├─Sequential: 1-3                        --\n",
       "│    └─Linear: 2-5                       9,800\n",
       "│    └─ReLU: 2-6                         --\n",
       "├─Sequential: 1-4                        --\n",
       "│    └─Linear: 2-7                       202\n",
       "│    └─Softmax: 2-8                      --\n",
       "=================================================================\n",
       "Total params: 30,071,033\n",
       "Trainable params: 30,071,033\n",
       "Non-trainable params: 0\n",
       "================================================================="
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 4 - Definição da Função de Perda e do Otimizador**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 5 - Hiperparâmetros**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 10\n",
    "total_step = X_train_tensor.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 6 - Treinamento do Modelo CNN e Avaliação do Desempenho**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 \t| Train loss: 1.24019 \t| Train acc: 0.9427 \t|\n",
      "Epoch: 1 \t| Train loss: 1.23835 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 2 \t| Train loss: 1.24691 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 3 \t| Train loss: 1.24667 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 4 \t| Train loss: 1.25075 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 5 \t| Train loss: 1.25527 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 6 \t| Train loss: 1.26295 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 7 \t| Train loss: 1.26547 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 8 \t| Train loss: 1.27142 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 9 \t| Train loss: 1.27688 \t| Train acc: 0.9474 \t|\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "acc_list = []\n",
    "acc_list_epoch = []\n",
    "batch_size = 1001\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    correct_sum = 0\n",
    "    for i in range(int(np.floor(total_step/batch_size))): # split data into batches\n",
    "        trainXT_seg = X_train_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        trainyT_seg = y_train_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        # Run the forward pass\n",
    "        outputs = model(trainXT_seg)\n",
    "        loss = criterion(outputs, trainyT_seg)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # Backprop and perform Adam optimisation\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        # Track the accuracy\n",
    "        total = trainyT_seg.size(0)\n",
    "        _, predicted = torch.max(outputs, -1)\n",
    "        _, actual = torch.max(trainyT_seg, -1)\n",
    "        correct = (predicted == actual).sum().item()\n",
    "        correct_sum = correct_sum + (correct/total)\n",
    "        acc_list.append(correct / total)\n",
    "\n",
    "    acc_list_epoch.append(correct_sum/int(np.floor(total_step/batch_size)))\n",
    "    print(f'Epoch: {epoch} \\t|' \\\n",
    "        f' Train loss: {np.round(loss.item(),5)} \\t|' \\\n",
    "        f' Train acc: {np.round(correct_sum/int(np.floor(total_step/batch_size)),4)} \\t|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 7 - Visualização da Curva de Acurácia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Training Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.grid(True)\n",
    "plt.autoscale(axis='x', tight=True)\n",
    "plt.plot(acc_list_epoch)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(VGG19) 8 - Rodando a rede nos dados de validação**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_todas_vgg19 = pd.read_csv(os.path.join(path_dir, \"deep_learning/vgg19/todas_vgg19.csv\"), low_memory=False)\n",
    "df_todas_vgg19 = df_todas_vgg19.reset_index()  \n",
    "df_todas_vgg19 = df_todas_vgg19.drop(df_todas_vgg19.index[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df_todas_vgg19 = df_todas_vgg19.astype(np.float32)\n",
    "X_validation_tensor = torch.tensor(new_df_todas_vgg19.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([44033, 1001])\n"
     ]
    }
   ],
   "source": [
    "print(X_validation_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0])]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicts = []\n",
    "batch_size = 1001\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    correct_sum = 0\n",
    "    for i in range(int(np.floor(total_step/batch_size))): # split data into batches\n",
    "        validationXT_seg = X_validation_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        outputs = model(validationXT_seg)\n",
    "        total = validationXT_seg.size(0)\n",
    "        _, predicted = torch.max(outputs, -1)\n",
    "        predicts.append(predicted)\n",
    "\n",
    "predicts[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Squeezenet*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_dir = os.path.dirname(\"\")\n",
    "\n",
    "df_treinamento_squeezenet = pd.read_csv(os.path.join(path_dir, \"deep_learning/squeezenet/treinamento_squeezenet.csv\"), low_memory=False)\n",
    "df_treinamento_squeezenet = df_treinamento_squeezenet.reset_index()  \n",
    "df_treinamento_squeezenet=df_treinamento_squeezenet.drop(df_treinamento_squeezenet.index[:2])\n",
    "\n",
    "df_teste_squeezenet = pd.read_csv(os.path.join(path_dir, \"deep_learning/squeezenet/teste_squeezenet.csv\"), low_memory=False)\n",
    "df_teste_squeezenet = df_teste_squeezenet.reset_index()  \n",
    "df_teste_squeezenet=df_teste_squeezenet.drop(df_teste_squeezenet.index[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 1 - Dividindo os dados (treinamento e teste)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df_treinamento_squeezenet = df_treinamento_squeezenet.drop('category', axis=1)\n",
    "new_df_treinamento_squeezenet = new_df_treinamento_squeezenet.astype(np.float32)\n",
    "X_train_tensor = torch.tensor(new_df_treinamento_squeezenet.values)\n",
    "\n",
    "for row in df_treinamento_squeezenet.itertuples(index=False, name='Pandas'):\n",
    "    y_train.append(0 if row.category == \"NaoPistas\" else 1)\n",
    "    \n",
    "new_df_teste_squeezenet = df_teste_squeezenet.drop('category', axis=1)\n",
    "new_df_teste_squeezenet = new_df_teste_squeezenet.astype(np.float32)\n",
    "X_test_tensor = torch.tensor(new_df_teste_squeezenet.values)\n",
    "\n",
    "for row in df_teste_squeezenet.itertuples(index=False, name='Pandas'):\n",
    "    y_test.append(0 if row.category == \"NaoPistas\" else 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_tensor = torch.tensor(y_train, device=device) \n",
    "y_test_tensor = torch.tensor(y_test,  device=device) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 2 - Verificação das Dimensões dos Dados de Treinamento e Teste**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([19622, 1001])\n",
      "torch.Size([39244])\n",
      "torch.Size([2465, 1001])\n",
      "torch.Size([4930])\n"
     ]
    }
   ],
   "source": [
    "print(X_train_tensor.shape)\n",
    "print(y_train_tensor.shape)\n",
    "print(X_test_tensor.shape)\n",
    "print(y_test_tensor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 3 - Definindo a Rede Neural Convolucional (CNN) para Classificação**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_timesteps, n_features, n_outputs = X_train_tensor.shape[0], X_train_tensor.shape[1], y_train_tensor.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvNet1D(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            nn.Conv1d(n_features, n_features, kernel_size=30),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.MaxPool1d(10))\n",
    "        self.layer2 = nn.Flatten()\n",
    "        self.layer3 = nn.Sequential(\n",
    "            nn.Linear(97,700),\n",
    "            nn.ReLU())\n",
    "        self.layer4 = nn.Sequential(\n",
    "            nn.Linear(700,2),\n",
    "            nn.Softmax(dim=1))\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ConvNet1D().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "=================================================================\n",
       "Layer (type:depth-idx)                   Param #\n",
       "=================================================================\n",
       "ConvNet1D                                --\n",
       "├─Sequential: 1-1                        --\n",
       "│    └─Conv1d: 2-1                       30,061,031\n",
       "│    └─ReLU: 2-2                         --\n",
       "│    └─Dropout: 2-3                      --\n",
       "│    └─MaxPool1d: 2-4                    --\n",
       "├─Flatten: 1-2                           --\n",
       "├─Sequential: 1-3                        --\n",
       "│    └─Linear: 2-5                       68,600\n",
       "│    └─ReLU: 2-6                         --\n",
       "├─Sequential: 1-4                        --\n",
       "│    └─Linear: 2-7                       1,402\n",
       "│    └─Softmax: 2-8                      --\n",
       "=================================================================\n",
       "Total params: 30,131,033\n",
       "Trainable params: 30,131,033\n",
       "Non-trainable params: 0\n",
       "================================================================="
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 4 - Definição da Função de Perda e do Otimizador**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 5 - Hiperparâmetros**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 10\n",
    "total_step = X_train_tensor.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 6 - Treinamento do Modelo CNN e Avaliação do Desempenho**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 \t| Train loss: 1.19196 \t| Train acc: 0.9297 \t|\n",
      "Epoch: 1 \t| Train loss: 1.22089 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 2 \t| Train loss: 1.24572 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 3 \t| Train loss: 1.26243 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 4 \t| Train loss: 1.27528 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 5 \t| Train loss: 1.28573 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 6 \t| Train loss: 1.29181 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 7 \t| Train loss: 1.2972 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 8 \t| Train loss: 1.29963 \t| Train acc: 0.9474 \t|\n",
      "Epoch: 9 \t| Train loss: 1.30212 \t| Train acc: 0.9474 \t|\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "acc_list = []\n",
    "acc_list_epoch = []\n",
    "batch_size = 1001\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    correct_sum = 0\n",
    "    for i in range(int(np.floor(total_step/batch_size))): # split data into batches\n",
    "        trainXT_seg = X_train_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        trainyT_seg = y_train_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        # Run the forward pass\n",
    "        outputs = model(trainXT_seg)\n",
    "        loss = criterion(outputs, trainyT_seg)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # Backprop and perform Adam optimisation\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        # Track the accuracy\n",
    "        total = trainyT_seg.size(0)\n",
    "        _, predicted = torch.max(outputs, -1)\n",
    "        _, actual = torch.max(trainyT_seg, -1)\n",
    "        correct = (predicted == actual).sum().item()\n",
    "        correct_sum = correct_sum + (correct/total)\n",
    "        acc_list.append(correct / total)\n",
    "\n",
    "    acc_list_epoch.append(correct_sum/int(np.floor(total_step/batch_size)))\n",
    "    print(f'Epoch: {epoch} \\t|' \\\n",
    "        f' Train loss: {np.round(loss.item(),5)} \\t|' \\\n",
    "        f' Train acc: {np.round(correct_sum/int(np.floor(total_step/batch_size)),4)} \\t|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 7 - Visualização da Curva de Acurácia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Training Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.grid(True)\n",
    "plt.autoscale(axis='x', tight=True)\n",
    "plt.plot(acc_list_epoch)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Squeezenet) 8 - Rodando a rede nos dados de validação**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_todas_squeezenet = pd.read_csv(os.path.join(path_dir, \"deep_learning/squeezenet/todas_squeezenet.csv\"), low_memory=False)\n",
    "df_todas_squeezenet = df_todas_squeezenet.reset_index()  \n",
    "df_todas_squeezenet = df_todas_squeezenet.drop(df_todas_squeezenet.index[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df_todas_squeezenet = df_todas_squeezenet.astype(np.float32)\n",
    "X_validation_tensor = torch.tensor(new_df_todas_squeezenet.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([25889, 1001])\n"
     ]
    }
   ],
   "source": [
    "print(X_validation_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0])]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicts = []\n",
    "batch_size = 1001\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    correct_sum = 0\n",
    "    for i in range(int(np.floor(total_step/batch_size))): # split data into batches\n",
    "        validationXT_seg = X_validation_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        outputs = model(validationXT_seg)\n",
    "        total = validationXT_seg.size(0)\n",
    "        _, predicted = torch.max(outputs, -1)\n",
    "        predicts.append(predicted)\n",
    "\n",
    "predicts[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Painters*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_dir = os.path.dirname(\"\")\n",
    "\n",
    "df_treinamento_painters = pd.read_csv(os.path.join(path_dir, \"deep_learning/painters/treinamento_painters.csv\"), low_memory=False)\n",
    "df_treinamento_painters = df_treinamento_painters.reset_index()  \n",
    "df_treinamento_painters=df_treinamento_painters.drop(df_treinamento_painters.index[:2])\n",
    "\n",
    "df_teste_painters = pd.read_csv(os.path.join(path_dir, \"deep_learning/painters/teste_painters.csv\"), low_memory=False)\n",
    "df_teste_painters = df_teste_painters.reset_index()  \n",
    "df_teste_painters=df_teste_painters.drop(df_teste_painters.index[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 1 - Dividindo os dados (treinamento e teste)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df_treinamento_painters = df_treinamento_painters.drop('category', axis=1)\n",
    "new_df_treinamento_painters = new_df_treinamento_painters.astype(np.float32)\n",
    "X_train_tensor = torch.tensor(new_df_treinamento_painters.values)\n",
    "\n",
    "for row in df_treinamento_painters.itertuples(index=False, name='Pandas'):\n",
    "    y_train.append(0 if row.category == \"NaoPistas\" else 1)\n",
    "    \n",
    "new_df_teste_painters = df_teste_painters.drop('category', axis=1)\n",
    "new_df_teste_painters = new_df_teste_painters.astype(np.float32)\n",
    "X_test_tensor = torch.tensor(new_df_teste_painters.values)\n",
    "\n",
    "for row in df_teste_painters.itertuples(index=False, name='Pandas'):\n",
    "    y_test.append(0 if row.category == \"NaoPistas\" else 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_tensor = torch.tensor(y_train, device=device) \n",
    "y_test_tensor = torch.tensor(y_test,  device=device) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 2 - Verificação das Dimensões dos Dados de Treinamento e Teste**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([19622, 2049])\n",
      "torch.Size([58866])\n",
      "torch.Size([2465, 2049])\n",
      "torch.Size([7395])\n"
     ]
    }
   ],
   "source": [
    "print(X_train_tensor.shape)\n",
    "print(y_train_tensor.shape)\n",
    "print(X_test_tensor.shape)\n",
    "print(y_test_tensor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 3 - Definindo a Rede Neural Convolucional (CNN) para Classificação**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_timesteps, n_features, n_outputs = X_train_tensor.shape[0], X_train_tensor.shape[1], y_train_tensor.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvNet1D(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            nn.Conv1d(n_features, n_features, kernel_size=30),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.MaxPool1d(10))\n",
    "        self.layer2 = nn.Flatten()\n",
    "        self.layer3 = nn.Sequential(\n",
    "            nn.Linear(202,100),\n",
    "            nn.ReLU())\n",
    "        self.layer4 = nn.Sequential(\n",
    "            nn.Linear(100,2),\n",
    "            nn.Softmax(dim=1))\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ConvNet1D().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "=================================================================\n",
       "Layer (type:depth-idx)                   Param #\n",
       "=================================================================\n",
       "ConvNet1D                                --\n",
       "├─Sequential: 1-1                        --\n",
       "│    └─Conv1d: 2-1                       125,954,079\n",
       "│    └─ReLU: 2-2                         --\n",
       "│    └─Dropout: 2-3                      --\n",
       "│    └─MaxPool1d: 2-4                    --\n",
       "├─Flatten: 1-2                           --\n",
       "├─Sequential: 1-3                        --\n",
       "│    └─Linear: 2-5                       20,300\n",
       "│    └─ReLU: 2-6                         --\n",
       "├─Sequential: 1-4                        --\n",
       "│    └─Linear: 2-7                       202\n",
       "│    └─Softmax: 2-8                      --\n",
       "=================================================================\n",
       "Total params: 125,974,581\n",
       "Trainable params: 125,974,581\n",
       "Non-trainable params: 0\n",
       "================================================================="
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 4 - Definição da Função de Perda e do Otimizador**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 5 - Hiperparâmetros**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 10\n",
    "total_step = X_train_tensor.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 6 - Treinamento do Modelo CNN e Avaliação do Desempenho**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 \t| Train loss: 1.31229 \t| Train acc: 0.8614 \t|\n",
      "Epoch: 1 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 2 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 3 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 4 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 5 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 6 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 7 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 8 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n",
      "Epoch: 9 \t| Train loss: 1.31229 \t| Train acc: 0.8889 \t|\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "acc_list = []\n",
    "acc_list_epoch = []\n",
    "batch_size = 2049\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    correct_sum = 0\n",
    "    for i in range(int(np.floor(total_step/batch_size))): # split data into batches\n",
    "        trainXT_seg = X_train_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        trainyT_seg = y_train_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        # Run the forward pass\n",
    "        outputs = model(trainXT_seg)\n",
    "        loss = criterion(outputs, trainyT_seg)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # Backprop and perform Adam optimisation\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        # Track the accuracy\n",
    "        total = trainyT_seg.size(0)\n",
    "        _, predicted = torch.max(outputs, -1)\n",
    "        _, actual = torch.max(trainyT_seg, -1)\n",
    "        correct = (predicted == actual).sum().item()\n",
    "        correct_sum = correct_sum + (correct/total)\n",
    "        acc_list.append(correct / total)\n",
    "\n",
    "    acc_list_epoch.append(correct_sum/int(np.floor(total_step/batch_size)))\n",
    "    print(f'Epoch: {epoch} \\t|' \\\n",
    "        f' Train loss: {np.round(loss.item(),5)} \\t|' \\\n",
    "        f' Train acc: {np.round(correct_sum/int(np.floor(total_step/batch_size)),4)} \\t|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 7 - Visualização da Curva de Acurácia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHHCAYAAACiOWx7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABPN0lEQVR4nO3deViVdf7/8dfhsCNubIKjgujPyizNhXGZytwyI52s3EZJS1ukTKYaNyQ1tfrOGN/KdOqb1qSkU5NOtuggiV2Oa5baYgpqWpooFqKgbOf+/WEcPQHFcuDmHJ6P6zrX1bnPfd/n/UFneHl/NothGIYAAADwqzzMLgAAAMAVEJoAAAAqgdAEAABQCYQmAACASiA0AQAAVAKhCQAAoBIITQAAAJVAaAIAAKgEQhMAAEAlEJoA1Jp7771XkZGR1br2qaeeksVicW5BAFADhCagAbJYLJV6paenm12q6e655x5ZLBb95S9/MbsUACazsPcc0PCsWLHC4f0//vEPpaam6s0333Q4PmDAAIWFhVX7e4qKimSz2eTj41Pla4uLi1VcXCxfX99qf39N5ebmKiwsTC1atFBJSYmOHj3K0y+gASM0AVB8fLwWL16s3/q/g/z8fPn7+9dRVeZbvny5HnjgAW3YsEG33HKL0tPTddNNN5ldVhmGYejixYvy8/MzuxTArdE9B6BcN998s6699lrt3r1bN954o/z9/TVjxgxJ0r///W8NGTJEERER8vHxUXR0tObNm6eSkhKHe/xyTNO3334ri8Wiv/71r3rllVcUHR0tHx8fde/eXbt27XK4trwxTRaLRfHx8Vq7dq2uvfZa+fj4qGPHjlq/fn2Z+tPT09WtWzf5+voqOjpaf//736s8TmrlypUaMGCA+vbtq6uvvlorV64s97xvvvlG99xzj0JCQuTn56cOHTpo5syZDuccP35c9913n/1nFhUVpYceekiFhYUVtleSXn/9dVksFn377bf2Y5GRkbr99tu1YcMGdevWTX5+fvr73/8u6VLQu+WWWxQaGiofHx9dc801WrJkSbl1f/TRR7rpppsUGBioxo0bq3v37kpJSZEkJSUlycvLS6dPny5z3aRJk9S0aVNdvHjxt3+IgBvxNLsAAPXXmTNnNHjwYI0cOVJ/+tOf7F11r7/+uho1aqSEhAQ1atRIH3/8sWbPnq3c3Fz9z//8z2/eNyUlRefOndMDDzwgi8Wi5557TnfeeacOHz4sLy+vX712y5Ytevfdd/Xwww8rMDBQL7zwgoYPH65jx44pKChIkvT555/r1ltvVXh4uObMmaOSkhLNnTtXISEhlW77iRMntGnTJr3xxhuSpFGjRun555/XSy+9JG9vb/t5+/bt0x/+8Ad5eXlp0qRJioyM1KFDh7Ru3TrNnz/ffq8ePXooJydHkyZN0lVXXaXjx4/rnXfeUX5+vsP9KuvAgQMaNWqUHnjgAU2cOFEdOnSQJC1ZskQdO3bUHXfcIU9PT61bt04PP/ywbDabJk+ebL/+9ddf14QJE9SxY0dNnz5dTZs21eeff67169dr9OjRGjt2rObOnavVq1crPj7efl1hYaHeeecdDR8+3NSuU8AUBoAGb/LkycYv/+/gpptuMiQZS5cuLXN+fn5+mWMPPPCA4e/vb1y8eNF+LC4uzmjTpo39/ZEjRwxJRlBQkPHjjz/aj//73/82JBnr1q2zH0tKSipTkyTD29vbyMzMtB/bu3evIcl48cUX7cdiY2MNf39/4/jx4/ZjGRkZhqenZ5l7VuSvf/2r4efnZ+Tm5hqGYRgHDx40JBlr1qxxOO/GG280AgMDjaNHjzoct9ls9v8eN26c4eHhYezatavM95SeV157DcMwli9fbkgyjhw5Yj/Wpk0bQ5Kxfv36MueX92czaNAgo23btvb3OTk5RmBgoBETE2NcuHChwrp79uxpxMTEOHz+7rvvGpKMTZs2lfkewN3RPQegQj4+Pho/fnyZ41eOnTl37pyys7P1hz/8Qfn5+frmm29+874jRoxQs2bN7O//8Ic/SJIOHz78m9f2799f0dHR9vfXXXedGjdubL+2pKREGzdu1LBhwxQREWE/r127dho8ePBv3r/UypUrNWTIEAUGBkqS2rdvr65duzp00Z0+fVqffPKJJkyYoNatWztcX9rVZrPZtHbtWsXGxqpbt25lvqe6A8ujoqI0aNCgMsev/LM5e/assrOzddNNN+nw4cM6e/asJCk1NVXnzp3TtGnTyjwturKecePGaceOHTp06JD92MqVK9WqVat6ObYLqG2EJgAVatmyZbldR1999ZX++Mc/qkmTJmrcuLFCQkL0pz/9SZLsv5h/zS8DRmmA+umnn6p8ben1pdeeOnVKFy5cULt27cqcV96x8uzfv1+ff/65evfurczMTPvr5ptv1vvvv6/c3FxJl0PetddeW+G9Tp8+rdzc3F89pzqioqLKPf7f//5X/fv3V0BAgJo2baqQkBD7WLTSP5vSEPRbNY0YMUI+Pj72oHj27Fm9//77GjNmDLMI0SARmgBUqLzZWDk5Obrpppu0d+9ezZ07V+vWrVNqaqqeffZZSZeerPwWq9Va7nGjEpN5a3JtZZUuyTB16lS1b9/e/vrb3/6mixcv6l//+pfTvqtURSHkl4PrS5X3Z3Po0CH169dP2dnZWrRokT744AOlpqZq6tSpkir3Z3OlZs2a6fbbb7eHpnfeeUcFBQX2gAw0NAwEB1Al6enpOnPmjN59913deOON9uNHjhwxsarLQkND5evrq8zMzDKflXfslwzDUEpKivr27auHH364zOfz5s3TypUrNX78eLVt21aS9OWXX1Z4v5CQEDVu3PhXz5EuP23LyclR06ZN7cePHj36mzWXWrdunQoKCvTee+85PJHbtGmTw3ml3Ztffvnlbz59GzdunIYOHapdu3Zp5cqV6tKlizp27FjpmgB3wpMmAFVS+qTnyic7hYWFevnll80qyYHValX//v21du1anThxwn48MzNTH3300W9e/9///lfffvutxo8fr7vuuqvMa8SIEdq0aZNOnDihkJAQ3XjjjVq2bJmOHTvmcJ/Sn4+Hh4eGDRumdevW6dNPPy3zfaXnlQaZTz75xP5ZXl6effZeZdt+5T2lS11qy5cvdzhv4MCBCgwM1MKFC8ssG/DLJ3aDBw9WcHCwnn32WW3evJmnTGjQeNIEoEp69eqlZs2aKS4uTo8++qgsFovefPNNp3aP1dRTTz2l//znP+rdu7ceeughlZSU6KWXXtK1116rPXv2/Oq1K1eulNVq1ZAhQ8r9/I477tDMmTO1atUqJSQk6IUXXlCfPn10ww03aNKkSYqKitK3336rDz74wP5dCxYs0H/+8x/ddNNNmjRpkq6++mr98MMPevvtt7VlyxY1bdpUAwcOVOvWrXXffffpiSeekNVq1bJlyxQSElImkFVk4MCB8vb2VmxsrB544AGdP39er776qkJDQ/XDDz/Yz2vcuLGef/553X///erevbtGjx6tZs2aae/evcrPz3cIal5eXho5cqReeuklWa1WjRo1qlK1AO6IJ00AqiQoKEjvv/++wsPDNWvWLP31r3/VgAED9Nxzz5ldml3Xrl310UcfqVmzZkpMTNRrr72muXPnql+/fr+6tlBRUZHefvtt9erVS82bNy/3nGuvvVZRUVH2cU/XX3+9tm/frhtvvFFLlizRo48+qn/961+644477Ne0bNlSO3bs0F133aWVK1fq0Ucf1T/+8Q/dfPPN9hXWvby8tGbNGkVHRysxMVEvvPCC7r//foc1kn5Lhw4d9M4778hisejxxx/X0qVLNWnSJE2ZMqXMuffdd5/ee+89NW7cWPPmzdNf/vIXffbZZ+XOMBw3bpwkqV+/fgoPD690PYC7YRsVAA3GsGHD9NVXXykjI8PsUlzK3r171blzZ/3jH//Q2LFjzS4HMA1PmgC4pQsXLji8z8jI0Icffqibb77ZnIJc2KuvvqpGjRrpzjvvNLsUwFSMaQLgltq2bat7771Xbdu21dGjR7VkyRJ5e3vrySefNLs0l7Fu3Tp9/fXXeuWVVxQfH6+AgACzSwJMRfccALc0fvx4bdq0SSdPnpSPj4969uypBQsW6IYbbjC7NJcRGRmprKwsDRo0SG+++aZ9dXSgoSI0AQAAVAJjmgAAACqB0AQAAFAJpg8EX7x4sf7nf/5HJ0+e1PXXX68XX3xRPXr0qPD85ORkLVmyRMeOHVNwcLDuuusuLVy40L72yrlz55SYmKg1a9bo1KlT6tKli/73f/9X3bt3t9/DMAwlJSXp1VdfVU5Ojnr37q0lS5aoffv2la7bZrPpxIkTCgwMZONKAABchGEYOnfunCIiIuThUcVnR4aJVq1aZXh7exvLli0zvvrqK2PixIlG06ZNjaysrHLPX7lypeHj42OsXLnSOHLkiLFhwwYjPDzcmDp1qv2ce+65x7jmmmuMzZs3GxkZGUZSUpLRuHFj4/vvv7ef88wzzxhNmjQx1q5da+zdu9e44447jKioKOPChQuVrv27774zJPHixYsXL168XPD13XffVTm3mDoQPCYmRt27d9dLL70k6dLTm1atWumRRx7RtGnTypwfHx+v/fv3Ky0tzX7sz3/+s3bs2KEtW7bowoULCgwM1L///W+HLRC6du2qwYMH6+mnn5ZhGIqIiNCf//xnPf7445Iu7c0UFham119/XSNHjqxU7WfPnlXTpk115MiRClcOdlVFRUX6z3/+o4EDB8rLy8vscpyKtrkm2ua63Ll9tM01/fjjj4qKilJOTo6aNGlSpWtN654rLCzU7t27NX36dPsxDw8P9e/fX9u2bSv3ml69emnFihXauXOnevToocOHD+vDDz+0r1BbXFyskpKSMtsk+Pn5acuWLZIu7cR+8uRJ9e/f3/55kyZNFBMTo23btlUYmgoKClRQUGB/f+7cOUmSr6+v/Pz8qvETqL88PT3l7+8vPz8/t/sfC21zTbTNdblz+2ibayrNCNUZWmNaaMrOzlZJSYnCwsIcjoeFhembb74p95rRo0crOztbffr0kWEYKi4u1oMPPqgZM2ZIkgIDA9WzZ0/NmzdPV199tcLCwvTWW29p27ZtateunSTp5MmT9u/55feWflaehQsXas6cOWWOb9q0yb53lLtJTU01u4RaQ9tcE21zXe7cPtrmWvLz86t9rekDwasiPT1dCxYs0Msvv6yYmBhlZmZqypQpmjdvnhITEyVJb775piZMmKCWLVvKarXqhhtu0KhRo7R79+4afff06dOVkJBgf5+bm6tWrVqpb9++CgoKqtG965uioiKlpqZqwIABbvcvDNrmmmib63Ln9tE213TmzJlqX2taaAoODpbValVWVpbD8aysLLVo0aLcaxITEzV27Fjdf//9kqROnTopLy9PkyZN0syZM+Xh4aHo6Ght3rxZeXl5ys3NVXh4uEaMGKG2bdtKkv3eWVlZDrt1Z2VlqXPnzhXW6+PjIx8fnzLHvby83O4vVCna5ppom2ty57ZJ7t0+2uZaatIe09Zp8vb2VteuXR0GddtsNqWlpalnz57lXpOfn19meqDVapUk/XI8e0BAgMLDw/XTTz9pw4YNGjp0qCQpKipKLVq0cPje3Nxc7dixo8LvBQAAMLV7LiEhQXFxcerWrZt69Oih5ORk5eXlafz48ZKkcePGqWXLllq4cKEkKTY2VosWLVKXLl3s3XOJiYmKjY21h6cNGzbIMAx16NBBmZmZeuKJJ3TVVVfZ72mxWPTYY4/p6aefVvv27RUVFaXExERFRERo2LBhpvwcAABA/WdqaBoxYoROnz6t2bNn6+TJk+rcubPWr19vH6R97NgxhydLs2bNksVi0axZs3T8+HGFhIQoNjZW8+fPt59z9uxZTZ8+Xd9//72aN2+u4cOHa/78+Q6P45588kl7t15OTo769Omj9evXl5l1BwAAUMr0geDx8fGKj48v97P09HSH956enkpKSlJSUlKF97vnnnt0zz33/Op3WiwWzZ07V3Pnzq1yvQAAoGFi7zkAAIBKIDQBAABUAqEJAACgEghNAAAAlUBoAgAAqATTZ8+h/ikqsenHAul4zgV5ehaZXY5TFRcX0zYXRNtclzu3j7a5pp/OXqj2tRbjl0tpo1Jyc3PVpEkTZWdnu9XecyU2QwOf36xDp/PMLgUAAKezFeTru+R7dPbsWTVu3LhK1/KkCQ6++zHfHph8PN2z99ZWUiKPn1eQdze0zTW5c9sk924fbXM9JSXV/91GaIKDjFPnJUkt/Q2lT+/vdhs1FhUV6cMPP9Rttw2ibS6Etrkud24fbXNNZ86cUfBfq3etez5KQLVlnDonSWrhT68tAABXIjTBQWbWpSdNLfwITQAAXInQBAel3XNhfiYXAgBAPUNogp3NZijz59BE9xwAAI4ITbA7nnNBF4pK5GW1KNjX7GoAAKhfCE2wK33KFBUUIKvF5GIAAKhnCE2wK5051y40wORKAACofwhNsMv4eeZcu5BGJlcCAED9Q2iCXenMOZ40AQBQFqEJkiTDuDxzjidNAACURWiCJOlk7kWdLyiW1cOiNkH+ZpcDAEC9Q2iCpMvjmSKD/OXtphv1AgBQE/x2hKTL45nahwaaXAkAAPUToQmSpMyflxtoH8Z4JgAAykNogqQrlhsIJTQBAFAeQhNkGAbdcwAA/AZCE3T6fIHOXiiSh0VqG8IaTQAAlIfQBGX+3DXXurm/fL2sJlcDAED9RGjCFSuB0zUHAEBFCE2wb9TLzDkAACpGaIJ95lx7Zs4BAFAhQhPse84xcw4AgIoRmhq4M+cLdCavUJIUHcrMOQAAKkJoauBKnzL9rpmf/L09Ta4GAID6i9DUwF1e1JLxTAAA/BpCUwNnH88UxngmAAB+DaGpgStdboA95wAA+HWEpgYuk+45AAAqhdDUgJ29UKSs3AJJPGkCAOC3EJoasNKnTOFNfBXo62VyNQAA1G+EpgYsk/FMAABUGqGpAbu8fQoz5wAA+C2EpgbMvkYTG/UCAPCbCE0NGDPnAACoPEJTA3W+oFjHcy5IYkwTAACVQWhqoA79/JQpJNBHTf29Ta4GAID6j9DUQLHnHAAAVUNoaqBKt08hNAEAUDmEpgYq8+flBtqxUS8AAJVCaGqg6J4DAKBqCE0N0IXCEn33U74kQhMAAJVlemhavHixIiMj5evrq5iYGO3cufNXz09OTlaHDh3k5+enVq1aaerUqbp48aL985KSEiUmJioqKkp+fn6Kjo7WvHnzZBiG/Zx7771XFovF4XXrrbfWWhvrm0Onz8swpOYB3gpq5GN2OQAAuARPM7989erVSkhI0NKlSxUTE6Pk5GQNGjRIBw4cUGhoaJnzU1JSNG3aNC1btky9evXSwYMH7QFo0aJFkqRnn31WS5Ys0RtvvKGOHTvq008/1fjx49WkSRM9+uij9nvdeuutWr58uf29j0/DCQ+li1qyPhMAAJVnamhatGiRJk6cqPHjx0uSli5dqg8++EDLli3TtGnTypy/detW9e7dW6NHj5YkRUZGatSoUdqxY4fDOUOHDtWQIUPs57z11ltlnmD5+PioRYsWtdW0eo2ZcwAAVJ1poamwsFC7d+/W9OnT7cc8PDzUv39/bdu2rdxrevXqpRUrVmjnzp3q0aOHDh8+rA8//FBjx451OOeVV17RwYMH9f/+3//T3r17tWXLFvuTqFLp6ekKDQ1Vs2bNdMstt+jpp59WUFBQhfUWFBSooKDA/j43N1eSVFRUpKKiomr9DMxy8OSl0NQ22L/c2kuPuVq7KoO2uSba5rrcuX20zTXVpE0W48rBPnXoxIkTatmypbZu3aqePXvajz/55JPavHmzw9OjK73wwgt6/PHHZRiGiouL9eCDD2rJkiX2z202m2bMmKHnnntOVqtVJSUlmj9/vkM4W7Vqlfz9/RUVFaVDhw5pxowZatSokbZt2yar1Vru9z711FOaM2dOmeMpKSny9/ev7o/BFPM/t+rURYsevqZEHZqY8scPAIAp8vPzNXr0aJ09e1aNGzeu0rWmds9VVXp6uhYsWKCXX35ZMTExyszM1JQpUzRv3jwlJiZKkv75z39q5cqVSklJUceOHbVnzx499thjioiIUFxcnCRp5MiR9nt26tRJ1113naKjo5Wenq5+/fqV+93Tp09XQkKC/X1ubq5atWqlvn37/uoTqvqmoNimqds3SpJGD+mrsMa+Zc4pKipSamqqBgwYIC8vr7ousVbRNtdE21yXO7ePtrmmM2fOVPta00JTcHCwrFarsrKyHI5nZWVVONYoMTFRY8eO1f333y/pUuDJy8vTpEmTNHPmTHl4eOiJJ57QtGnT7MGoU6dOOnr0qBYuXGgPTb/Utm1bBQcHKzMzs8LQ5OPjU+5gcS8vL5f6C3XoTK5shhTo66mWzRvJYrFUeK6rta0qaJtrom2uy53bR9tcS03aY9qSA97e3uratavS0tLsx2w2m9LS0hy6666Un58vDw/Hkku700p7GSs6x2azVVjL999/rzNnzig8PLxabXElGVmXF7X8tcAEAAAcmdo9l5CQoLi4OHXr1k09evRQcnKy8vLy7LPpxo0bp5YtW2rhwoWSpNjYWC1atEhdunSxd88lJiYqNjbWHp5iY2M1f/58tW7dWh07dtTnn3+uRYsWacKECZKk8+fPa86cORo+fLhatGihQ4cO6cknn1S7du00aNAgc34QdejySuBsnwIAQFWYGppGjBih06dPa/bs2Tp58qQ6d+6s9evXKywsTJJ07Ngxh6dGs2bNksVi0axZs3T8+HGFhITYQ1KpF198UYmJiXr44Yd16tQpRURE6IEHHtDs2bMlXXrqtG/fPr3xxhvKyclRRESEBg4cqHnz5jWItZoyS5cbCGO5AQAAqsL0geDx8fGKj48v97P09HSH956enkpKSlJSUlKF9wsMDFRycrKSk5PL/dzPz08bNmyobrkur7R7joUtAQCoGtO3UUHdKSqx6Uh2niSpfRjdcwAAVAWhqQE5eiZPxTZDAd5WRTQpu9QAAACoGKGpAbmya46ZcwAAVA2hqQHJsG/US9ccAABVRWhqQOzLDTBzDgCAKiM0NSAZWT8vN8DMOQAAqozQ1EAUl9h0uHTmHN1zAABUGaGpgfjupwsqLLbJ18tDLZv5mV0OAAAuh9DUQJR2zUWHNJLVg5lzAABUFaGpgbi85xzjmQAAqA5CUwORaZ85x3gmAACqg9DUQGT8vFEve84BAFA9hKYGwGYzLj9pIjQBAFAthKYG4HjOBV0sssnb6qHWzf3NLgcAAJdEaGoASrvm2oYEyNPKHzkAANXBb9AG4MqNegEAQPUQmhqAy8sNMHMOAIDqIjQ1AGzUCwBAzRGa3JxhGMpko14AAGqM0OTmfjh7UXmFJfL0sKhNUIDZ5QAA4LIITW6utGsuMjhA3p78cQMAUF38FnVzGXTNAQDgFIQmN8dK4AAAOAehyc2Vds+1Y6NeAABqhNDkxgzDoHsOAAAnITS5sdPnCpR7sVgeFikqmJlzAADUBKHJjZV2zbUJCpCvl9XkagAAcG2EJjdW2jXHnnMAANQcocmNZTBzDgAApyE0uTH2nAMAwHkITW7s8hpNLDcAAEBNEZrc1JnzBfoxr1AWixQdwpMmAABqitDkpkq75n7XzE9+3sycAwCgpghNbiqDrjkAAJyK0OSmMlkJHAAApyI0uSn7nnOEJgAAnILQ5KYuLzdA9xwAAM5AaHJDOfmFOn2uQBJPmgAAcBZCkxsqXZ8poomvGvl4mlwNAADugdDkhuzjmeiaAwDAaQhNbigjiz3nAABwNkKTG8o4xXIDAAA4G6HJDWWyUS8AAE5HaHIz5y4W6YezFyVJ7UIY0wQAgLMQmtxM6VOm0EAfNfH3MrkaAADcB6HJzWTQNQcAQK0gNLmZTDbqBQCgVhCa3EzGzxv1shI4AADORWhyM/buOUITAABORWhyI/mFxfr+pwuS2KgXAABnMz00LV68WJGRkfL19VVMTIx27tz5q+cnJyerQ4cO8vPzU6tWrTR16lRdvHjR/nlJSYkSExMVFRUlPz8/RUdHa968eTIMw36OYRiaPXu2wsPD5efnp/79+ysjI6PW2lhXDp3KkyQFBXireYC3ydUAAOBeTA1Nq1evVkJCgpKSkvTZZ5/p+uuv16BBg3Tq1Klyz09JSdG0adOUlJSk/fv367XXXtPq1as1Y8YM+znPPvuslixZopdeekn79+/Xs88+q+eee04vvvii/ZznnntOL7zwgpYuXaodO3YoICBAgwYNcghfrqh0JXDGMwEA4HymhqZFixZp4sSJGj9+vK655hotXbpU/v7+WrZsWbnnb926Vb1799bo0aMVGRmpgQMHatSoUQ5Pp7Zu3aqhQ4dqyJAhioyM1F133aWBAwfazzEMQ8nJyZo1a5aGDh2q6667Tv/4xz904sQJrV27ti6aXWtYbgAAgNpjWmgqLCzU7t271b9//8vFeHiof//+2rZtW7nX9OrVS7t377YHoMOHD+vDDz/Ubbfd5nBOWlqaDh48KEnau3evtmzZosGDB0uSjhw5opMnTzp8b5MmTRQTE1Ph97qKyxv1Mp4JAABn8zTri7Ozs1VSUqKwsDCH42FhYfrmm2/KvWb06NHKzs5Wnz59ZBiGiouL9eCDDzp0z02bNk25ubm66qqrZLVaVVJSovnz52vMmDGSpJMnT9q/55ffW/pZeQoKClRQUGB/n5ubK0kqKipSUVFRFVpee0qXG4gK8q1RTaXX1pd2ORNtc020zXW5c/tom2uqSZtMC03VkZ6ergULFujll19WTEyMMjMzNWXKFM2bN0+JiYmSpH/+859auXKlUlJS1LFjR+3Zs0ePPfaYIiIiFBcXV+3vXrhwoebMmVPm+KZNm+Tv71/t+zpLYYl07EerJIuO7tuhn8rPnVWSmppa85vUU7TNNdE21+XO7aNtriU/P7/a15oWmoKDg2W1WpWVleVwPCsrSy1atCj3msTERI0dO1b333+/JKlTp07Ky8vTpEmTNHPmTHl4eOiJJ57QtGnTNHLkSPs5R48e1cKFCxUXF2e/d1ZWlsLDwx2+t3PnzhXWO336dCUkJNjf5+bmqlWrVurbt6+CgoKq9TNwpv0/nJOxc5ua+HlqxNABslgs1b5XUVGRUlNTNWDAAHl5udf+dbTNNdE21+XO7aNtrunMmTPVvta00OTt7a2uXbsqLS1Nw4YNkyTZbDalpaUpPj6+3Gvy8/Pl4eE4DMtqtUqSfUmBis6x2WySpKioKLVo0UJpaWn2kJSbm6sdO3booYceqrBeHx8f+fj4lDnu5eVVL/5CHfnx5/WZQgPl7e2c5QbqS9tqA21zTbTNdblz+2iba6lJe0ztnktISFBcXJy6deumHj16KDk5WXl5eRo/frwkady4cWrZsqUWLlwoSYqNjdWiRYvUpUsXe/dcYmKiYmNj7eEpNjZW8+fPV+vWrdWxY0d9/vnnWrRokSZMmCBJslgseuyxx/T000+rffv2ioqKUmJioiIiIuzhzRVlMnMOAIBaZWpoGjFihE6fPq3Zs2fr5MmT6ty5s9avX28fpH3s2DGHp0azZs2SxWLRrFmzdPz4cYWEhNhDUqkXX3xRiYmJevjhh3Xq1ClFRETogQce0OzZs+3nPPnkk/ZuvZycHPXp00fr16+Xr69v3TXeyUpDUztmzgEAUCtMHwgeHx9fYXdcenq6w3tPT08lJSUpKSmpwvsFBgYqOTlZycnJFZ5jsVg0d+5czZ07tzol10vsOQcAQO0yfRsV1FxhsU3fZl/aQoXuOQAAagehyQ0cPZOnYpuhRj6eatHYdbsYAQCozwhNbiDDPp6pUY2WGgAAABUjNLmBy9un0DUHAEBtITS5gYxTl7ZPYTwTAAC1h9DkBuxrNLHcAAAAtYbQ5OKKS2w6fPrSzLl2dM8BAFBrCE0u7tiP+SosscnPy6qWTf3MLgcAALdFaHJxV86c8/Bg5hwAALWF0OTiMlkJHACAOkFocnEZWZdmzrVj5hwAALWK0OTiMpg5BwBAnSA0ubASm0H3HAAAdYTQ5MKO/3RBBcU2eXt6qFVzf7PLAQDArRGaXFjpSuDRIY1kZeYcAAC1itDkwjLomgMAoM4QmlwYG/UCAFB3CE0uLJONegEAqDOEJhdlGMYVq4Gz3AAAALWN0OSiTpy9qPzCEnlZLWoTxMw5AABqG6HJRZWuBB4VHCAvK3+MAADUNn7buqhMVgIHAKBOEZpcVOnMuXbMnAMAoE4QmlxUBjPnAACoU1UOTZGRkZo7d66OHTtWG/WgEq6cOUf3HAAAdaPKoemxxx7Tu+++q7Zt22rAgAFatWqVCgoKaqM2VODUuQKdu1gsq4dFkcHMnAMAoC5UKzTt2bNHO3fu1NVXX61HHnlE4eHhio+P12effVYbNeIXSscztQnyl4+n1eRqAABoGKo9pumGG27QCy+8oBMnTigpKUn/93//p+7du6tz585atmyZDMNwZp24gn08E4PAAQCoM57VvbCoqEhr1qzR8uXLlZqaqt///ve677779P3332vGjBnauHGjUlJSnFkrfsZ4JgAA6l6VQ9Nnn32m5cuX66233pKHh4fGjRun559/XldddZX9nD/+8Y/q3r27UwvFZZmlG/Uycw4AgDpT5dDUvXt3DRgwQEuWLNGwYcPk5eVV5pyoqCiNHDnSKQXCkWEYOvhz9xxrNAEAUHeqHJoOHz6sNm3a/Oo5AQEBWr58ebWLQsXO5BUqJ79IFosUHUJoAgCgrlR5IPipU6e0Y8eOMsd37NihTz/91ClFoWKlM+daNfOXrxcz5wAAqCtVDk2TJ0/Wd999V+b48ePHNXnyZKcUhYplMnMOAABTVDk0ff3117rhhhvKHO/SpYu+/vprpxSFipXOnGvHIHAAAOpUlUOTj4+PsrKyyhz/4Ycf5OlZ7RUMUEml3XMsNwAAQN2qcmgaOHCgpk+frrNnz9qP5eTkaMaMGRowYIBTi0NZl9do4kkTAAB1qcqPhv7617/qxhtvVJs2bdSlSxdJ0p49exQWFqY333zT6QXisp/yCpV9/tI+f9GEJgAA6lSVQ1PLli21b98+rVy5Unv37pWfn5/Gjx+vUaNGlbtmE5wn8/Slp0wtm/qpkQ9doQAA1KVq/eYNCAjQpEmTnF0LfkPpeCYWtQQAoO5V+3HF119/rWPHjqmwsNDh+B133FHjolA+NuoFAMA81VoR/I9//KO++OILWSwWGYYhSbJYLJKkkpIS51YIu8xT7DkHAIBZqjx7bsqUKYqKitKpU6fk7++vr776Sp988om6deum9PT0WigRpS53z7HcAAAAda3KT5q2bdumjz/+WMHBwfLw8JCHh4f69OmjhQsX6tFHH9Xnn39eG3U2eLkXi3Qy96IkxjQBAGCGKj9pKikpUWDgpScdwcHBOnHihCSpTZs2OnDggHOrg11p11xYYx818WOWIgAAda3KT5quvfZa7d27V1FRUYqJidFzzz0nb29vvfLKK2rbtm1t1AhJmawEDgCAqaocmmbNmqW8vDxJ0ty5c3X77bfrD3/4g4KCgrR69WqnF4hLSmfO0TUHAIA5qhyaBg0aZP/vdu3a6ZtvvtGPP/6oZs2a2WfQwfkymDkHAICpqjSmqaioSJ6envryyy8djjdv3pzAVMvYqBcAAHNVKTR5eXmpdevWrMVUx/IKinU854IkFrYEAMAsVZ49N3PmTM2YMUM//vij04pYvHixIiMj5evrq5iYGO3cufNXz09OTlaHDh3k5+enVq1aaerUqbp48aL988jISFksljKvyZMn28+5+eaby3z+4IMPOq1NznTo5z3nght5q1mAt8nVAADQMFV5TNNLL72kzMxMRUREqE2bNgoICHD4/LPPPqvS/VavXq2EhAQtXbpUMTExSk5O1qBBg3TgwAGFhoaWOT8lJUXTpk3TsmXL1KtXLx08eFD33nuvLBaLFi1aJEnatWuXw9OwL7/8UgMGDNDdd9/tcK+JEydq7ty59vf+/v5Vqr2usOccAADmq3JoGjZsmFMLWLRokSZOnKjx48dLkpYuXaoPPvhAy5Yt07Rp08qcv3XrVvXu3VujR4+WdOmp0qhRo7Rjxw77OSEhIQ7XPPPMM4qOjtZNN93kcNzf318tWrRwantqg30QOOOZAAAwTZVDU1JSktO+vLCwULt379b06dPtxzw8PNS/f39t27at3Gt69eqlFStWaOfOnerRo4cOHz6sDz/8UGPHjq3wO1asWKGEhIQyg9VXrlypFStWqEWLFoqNjVViYmK9fNqUWbpRLzPnAAAwTZVDkzNlZ2erpKREYWFhDsfDwsL0zTfflHvN6NGjlZ2drT59+sgwDBUXF+vBBx/UjBkzyj1/7dq1ysnJ0b333lvmPm3atFFERIT27dunv/zlLzpw4IDefffdcu9TUFCggoIC+/vc3FxJl2YUFhUVVbbJ1XIw61JoimruV+vfJcn+HXXxXXWNtrkm2ua63Ll9tM011aRNFsMwjKpc4OHh8avLC1RlZt2JEyfUsmVLbd26VT179rQff/LJJ7V582aHLrdS6enpGjlypJ5++mnFxMQoMzNTU6ZM0cSJE5WYmFjm/EGDBsnb21vr1q371Vo+/vhj9evXT5mZmYqOji7z+VNPPaU5c+aUOZ6SklKrT6cKS6Qnd1plyKJ5XYvVmHHgAABUW35+vkaPHq2zZ8+qcePGVbq2yk+a1qxZ4/C+qKhIn3/+ud54441yQ8WvCQ4OltVqVVZWlsPxrKysCscaJSYmauzYsbr//vslSZ06dVJeXp4mTZqkmTNnysPj8oTAo0ePauPGjRU+PbpSTEyMJFUYmqZPn66EhAT7+9zcXLVq1Up9+/ZVUFDQbze2mr7+IVfGzu1q6uelEUMH1Ml6WEVFRUpNTdWAAQPk5eVe+9zRNtdE21yXO7ePtrmmM2fOVPvaKoemoUOHljl21113qWPHjlq9erXuu+++St/L29tbXbt2VVpamn2Auc1mU1pamuLj48u9Jj8/3yEYSZLVapUk/fKh2fLlyxUaGqohQ4b8Zi179uyRJIWHh5f7uY+Pj3x8fMoc9/LyqtW/UN/+eGkphfZhjeTtXbePmWq7bWaiba6Jtrkud24fbXMtNWmP08Y0/f73v9ekSZOqfF1CQoLi4uLUrVs39ejRQ8nJycrLy7PPphs3bpxatmyphQsXSpJiY2O1aNEidenSxd49l5iYqNjYWHt4ki6Fr+XLlysuLk6eno7NPHTokFJSUnTbbbcpKChI+/bt09SpU3XjjTfquuuuq8FPwfkuLzfAzDkAAMzklNB04cIFvfDCC2rZsmWVrx0xYoROnz6t2bNn6+TJk+rcubPWr19vHxx+7NgxhydLs2bNksVi0axZs3T8+HGFhIQoNjZW8+fPd7jvxo0bdezYMU2YMKHMd3p7e2vjxo32gNaqVSsNHz5cs2bNqnL9ta10o15WAgcAwFxVDk2/3JjXMAydO3dO/v7+WrFiRbWKiI+Pr7A7Lj093eG9p6enkpKSfnPpg4EDB5bprivVqlUrbd68uVq11jU26gUAoH6ocmh6/vnnHUKTh4eHQkJCFBMTo2bNmjm1uIauoLhER8/kS2JhSwAAzFbl0PTL9Y5Qe77NzleJzVCgj6fCGpcdhA4AAOpOlTfsXb58ud5+++0yx99++2298cYbTikKl5SOZ2oX1qhOlhoAAAAVq3JoWrhwoYKDg8scDw0N1YIFC5xSFC4pnTnHIHAAAMxX5dB07NgxRUVFlTnepk0bHTt2zClF4ZJMNuoFAKDeqHJoCg0N1b59+8oc37t3b62ujN0QXdk9BwAAzFXl0DRq1Cg9+uij2rRpk0pKSlRSUqKPP/5YU6ZM0ciRI2ujxgapqMSmI9l5kuieAwCgPqjy7Ll58+bp22+/Vb9+/ewrbdtsNo0bN44xTU509Ey+ikoM+XtbFdHEz+xyAABo8Kocmry9vbV69Wo9/fTT2rNnj/z8/NSpUye1adOmNuprsDJLu+ZCG8nDg5lzAACYrdrbqLRv317t27d3Zi24wuU95+iaAwCgPqjymKbhw4fr2WefLXP8ueee09133+2UonDF9inMnAMAoF6ocmj65JNPdNttt5U5PnjwYH3yySdOKQpXhiaeNAEAUB9UOTSdP39e3t7eZY57eXkpNzfXKUU1dCU2Q4dOs1EvAAD1SZVDU6dOnbR69eoyx1etWqVrrrnGKUU1dN/9mK/CYpt8PD30u2b+ZpcDAABUjYHgiYmJuvPOO3Xo0CHdcsstkqS0tDSlpKTonXfecXqBDVFp11x0SCNZmTkHAEC9UOXQFBsbq7Vr12rBggV655135Ofnp+uvv14ff/yxmjdvXhs1NjilK4HTNQcAQP1RrSUHhgwZoiFDhkiScnNz9dZbb+nxxx/X7t27VVJS4tQCG6JMNuoFAKDeqfKYplKffPKJ4uLiFBERob/97W+65ZZbtH37dmfW1mCVds+1Y7kBAADqjSo9aTp58qRef/11vfbaa8rNzdU999yjgoICrV27lkHgTmKzGco8xcw5AADqm0o/aYqNjVWHDh20b98+JScn68SJE3rxxRdrs7YG6XjOBV0oKpGX1aI2zZk5BwBAfVHpJ00fffSRHn30UT300ENsn1KLSp8ytQ1uJE9rtXtPAQCAk1X6t/KWLVt07tw5de3aVTExMXrppZeUnZ1dm7U1SKWhqR1dcwAA1CuVDk2///3v9eqrr+qHH37QAw88oFWrVikiIkI2m02pqak6d+5cbdbZYNiXG2DmHAAA9UqV+38CAgI0YcIEbdmyRV988YX+/Oc/65lnnlFoaKjuuOOO2qixQWGjXgAA6qcaDZrp0KGDnnvuOX3//fd66623nFVTg2UYxuU1muieAwCgXnHKSGOr1aphw4bpvffec8btGqys3AKdKyiW1cOiyKAAs8sBAABXYHpWPVI6nikyyF/envzRAABQn/CbuR7JyGI8EwAA9RWhqR7JYCVwAADqLUJTPZL5c/dcO5YbAACg3iE01ROGYegg3XMAANRbhKZ6Ivt8oc5eKJKHRWobwsw5AADqG0JTPVE6c651c3/5ellNrgYAAPwSoamesO85R9ccAAD1EqGpnshgJXAAAOo1QlM9wUa9AADUb4SmeiKTjXoBAKjXCE31wI95hco+XyhJig5l5hwAAPURoakeKH3K9LtmfvL39jS5GgAAUB5CUz3AeCYAAOo/QlM9cHnmHOOZAACorwhN9cDlNZp40gQAQH1FaKoH6J4DAKD+IzSZ7OyFImXlFkjiSRMAAPUZoclkpV1z4U18FejrZXI1AACgIoQmk2X+3DXHUyYAAOo3QpPJ7DPnWAkcAIB6jdBksoxTbNQLAIArIDSZ7PKec4QmAADqM0KTic4XFOt4zgVJjGkCAKC+qxehafHixYqMjJSvr69iYmK0c+fOXz0/OTlZHTp0kJ+fn1q1aqWpU6fq4sWL9s8jIyNlsVjKvCZPnmw/5+LFi5o8ebKCgoLUqFEjDR8+XFlZWbXWxvIc+vkpU0igj5r6e9fpdwMAgKoxPTStXr1aCQkJSkpK0meffabrr79egwYN0qlTp8o9PyUlRdOmTVNSUpL279+v1157TatXr9aMGTPs5+zatUs//PCD/ZWamipJuvvuu+3nTJ06VevWrdPbb7+tzZs368SJE7rzzjtrt7G/kEHXHAAALsP00LRo0SJNnDhR48eP1zXXXKOlS5fK399fy5YtK/f8rVu3qnfv3ho9erQiIyM1cOBAjRo1yuHpVEhIiFq0aGF/vf/++4qOjtZNN90kSTp79qxee+01LVq0SLfccou6du2q5cuXa+vWrdq+fXudtFtiJXAAAFyJqaGpsLBQu3fvVv/+/e3HPDw81L9/f23btq3ca3r16qXdu3fbQ9Lhw4f14Ycf6rbbbqvwO1asWKEJEybIYrFIknbv3q2ioiKH773qqqvUunXrCr+3NmT+vNxAOzbqBQCg3vM088uzs7NVUlKisLAwh+NhYWH65ptvyr1m9OjRys7OVp8+fWQYhoqLi/Xggw86dM9dae3atcrJydG9995rP3by5El5e3uradOmZb735MmT5d6noKBABQUF9ve5ubmSpKKiIhUVFf1WU8t1MOvSk6ao5r7VvkdtKK2lPtXkLLTNNdE21+XO7aNtrqkmbTI1NFVHenq6FixYoJdfflkxMTHKzMzUlClTNG/ePCUmJpY5/7XXXtPgwYMVERFRo+9duHCh5syZU+b4pk2b5O/vX+X7FZZI3/9klWTR0X3bdWZ/jcqrFaVjwdwRbXNNtM11uXP7aJtryc/Pr/a1poam4OBgWa3WMrPWsrKy1KJFi3KvSUxM1NixY3X//fdLkjp16qS8vDxNmjRJM2fOlIfH5R7Ho0ePauPGjXr33Xcd7tGiRQsVFhYqJyfH4WnTr33v9OnTlZCQYH+fm5urVq1aqW/fvgoKCqpSuyXpqxO5MnZuVzN/L90zdGCVr69NRUVFSk1N1YABA+Tl5V774dE210TbXJc7t4+2uaYzZ85U+1pTQ5O3t7e6du2qtLQ0DRs2TJJks9mUlpam+Pj4cq/Jz893CEaSZLVaJUmGYTgcX758uUJDQzVkyBCH4127dpWXl5fS0tI0fPhwSdKBAwd07Ngx9ezZs9zv9fHxkY+PT5njXl5e1foL9e2Pl5ZIaB8WWG//Qla3ba6Atrkm2ua63Ll9tM211KQ9pnfPJSQkKC4uTt26dVOPHj2UnJysvLw8jR8/XpI0btw4tWzZUgsXLpQkxcbGatGiRerSpYu9ey4xMVGxsbH28CRdCl/Lly9XXFycPD0dm9mkSRPdd999SkhIUPPmzdW4cWM98sgj6tmzp37/+9/XSbuZOQcAgGsxPTSNGDFCp0+f1uzZs3Xy5El17txZ69evtw8OP3bsmMOTpVmzZslisWjWrFk6fvy4QkJCFBsbq/nz5zvcd+PGjTp27JgmTJhQ7vc+//zz8vDw0PDhw1VQUKBBgwbp5Zdfrr2G/sLljXoJTQAAuALTQ5MkxcfHV9gdl56e7vDe09NTSUlJSkpK+tV7Dhw4sEx33ZV8fX21ePFiLV68uMr1OoN9zzmWGwAAwCWYvrhlQ1RQXKJvz+RJ4kkTAACugtBkgiPZebIZUmNfT4UElh1cDgAA6h9Ckwns45nCAu2rlAMAgPqN0GQCNuoFAMD1EJpMkPnzcgPtCE0AALgMQpMJruyeAwAAroHQVMeKSmw6ks3MOQAAXA2hqY4dPZOnYpuhAG+rwpv4ml0OAACoJEJTHSvtmmsX2oiZcwAAuBBCUx0rnTnXLpTxTAAAuBJCUx2zLzcQxngmAABcCaGpjmVkXVpugEHgAAC4FkJTHSousemwfeYc3XMAALgSQlMd+u6nCyostsnXy0Mtm/mZXQ4AAKgCQlMdKu2aiw5pJKsHM+cAAHAlhKY6xJ5zAAC4LkJTHco8xfYpAAC4KkJTHcpgo14AAFwWoamO2GzG5SdNhCYAAFwOoamOHM+5oItFNnlbPdS6ub/Z5QAAgCoiNNWR0q65tiEB8rTyYwcAwNXw27uOXLlRLwAAcD2EpjpyebkBZs4BAOCKCE11hI16AQBwbYSmOmAYhjLZqBcAAJdGaKoDP5y9qLzCEnl6WNQmKMDscgAAQDUQmupAaddcZHCAvD35kQMA4Ir4DV4HMuiaAwDA5RGa6gArgQMA4PoITXWgtHuuHRv1AgDgsghNtcwwDLrnAABwA4SmWnb6XIFyLxbLwyJFBTNzDgAAV0VoqmWlXXNtggLk62U1uRoAAFBdhKZaVto1x55zAAC4NkJTLctg5hwAAG6B0FTL2HMOAAD3QGiqZZfXaGK5AQAAXBmhqRadOV+gH/MKZbFI0SE8aQIAwJURmmpRadfc75r5yc+bmXMAALgyQlMtyqBrDgAAt0FoqkWZrAQOAIDbIDTVIvuec4QmAABcHqGpFl1eboDuOQAAXB2hqZaczS/S6XMFknjSBACAOyA01ZLM05fGM0U08VUjH0+TqwEAADVFaKolGVk/j2eiaw4AALdAaKol7DkHAIB7ITTVEkITAADuhdBUS+xrNLFRLwAAboHQVAvOXSzSibMXJUntQhjTBACAOyA01YJDp/MkSaGBPmri72VyNQAAwBlMD02LFy9WZGSkfH19FRMTo507d/7q+cnJyerQoYP8/PzUqlUrTZ06VRcvXnQ45/jx4/rTn/6koKAg+fn5qVOnTvr000/tn997772yWCwOr1tvvdVpbcqgaw4AALdj6gJCq1evVkJCgpYuXaqYmBglJydr0KBBOnDggEJDQ8ucn5KSomnTpmnZsmXq1auXDh48aA9AixYtkiT99NNP6t27t/r27auPPvpIISEhysjIULNmzRzudeutt2r58uX29z4+Pk5rVyYb9QIA4HZMDU2LFi3SxIkTNX78eEnS0qVL9cEHH2jZsmWaNm1amfO3bt2q3r17a/To0ZKkyMhIjRo1Sjt27LCf8+yzz6pVq1YOgSgqKqrMvXx8fNSiRQtnN0kSe84BAOCOTAtNhYWF2r17t6ZPn24/5uHhof79+2vbtm3lXtOrVy+tWLFCO3fuVI8ePXT48GF9+OGHGjt2rP2c9957T4MGDdLdd9+tzZs3q2XLlnr44Yc1ceJEh3ulp6crNDRUzZo10y233KKnn35aQUFBFdZbUFCggoIC+/vc3FxJUlFRkYqKihzOPfhz91xUkG+Zz1xBac2uWPtvoW2uiba5LnduH21zTTVpk8UwDMOJtVTaiRMn1LJlS23dulU9e/a0H3/yySe1efNmh6dHV3rhhRf0+OOPyzAMFRcX68EHH9SSJUvsn/v6+kqSEhISdPfdd2vXrl2aMmWKli5dqri4OEnSqlWr5O/vr6ioKB06dEgzZsxQo0aNtG3bNlmt1nK/96mnntKcOXPKHE9JSZG/v7/9fUGJ9JedVhmyaH63YjViHDgAAPVGfn6+Ro8erbNnz6px48ZVutalQlN6erpGjhypp59+WjExMcrMzNSUKVM0ceJEJSYmSpK8vb3VrVs3bd261X7do48+ql27dlX4BOvw4cOKjo7Wxo0b1a9fv3LPKe9JU6tWrfTDDz84PKH66kSuhi3ZruYBXtoxrW/Vfij1RFFRkVJTUzVgwAB5eblX6qNtrom2uS53bh9tc01nzpxReHh4tUKTad1zwcHBslqtysrKcjielZVV4VijxMREjR07Vvfff78kqVOnTsrLy9OkSZM0c+ZMeXh4KDw8XNdcc43DdVdffbX+9a9/VVhL27ZtFRwcrMzMzApDk4+PT7mDxb28vBz+Qh358YKkS4PAXf0v2i/b5k5om2uiba7LndtH21xLTdpj2pID3t7e6tq1q9LS0uzHbDab0tLSHJ48XSk/P18eHo4ll3anlT4w6927tw4cOOBwzsGDB9WmTZsKa/n+++/tybOmSjfqZbkBAADci6nrNCUkJOjVV1/VG2+8of379+uhhx5SXl6efTbduHHjHAaKx8bGasmSJVq1apWOHDmi1NRUJSYmKjY21h6epk6dqu3bt2vBggXKzMxUSkqKXnnlFU2ePFmSdP78eT3xxBPavn27vv32W6WlpWno0KFq166dBg0aVOM2ZbDcAAAAbsnUJQdGjBih06dPa/bs2Tp58qQ6d+6s9evXKywsTJJ07NgxhydLs2bNksVi0axZs3T8+HGFhIQoNjZW8+fPt5/TvXt3rVmzRtOnT9fcuXMVFRWl5ORkjRkzRtKlJ1P79u3TG2+8oZycHEVERGjgwIGaN2+eU9ZqymSjXgAA3JKpoUmS4uPjFR8fX+5n6enpDu89PT2VlJSkpKSkX73n7bffrttvv73cz/z8/LRhw4Zq1fpbLhaV6OiZS1uotKN7DgAAt2L6Niru5Eh2nmyG1MTPSyGNnLfCOAAAMB+hyYkyruias1gsJlcDAACcidDkRJls1AsAgNsiNDnR5T3nmDkHAIC7ITQ5UQYz5wAAcFuEJicpLLbp2+xLM+fongMAwP0Qmpzk6Jk8FdsMNfLxVIvGvmaXAwAAnIzQ5CSXxzMxcw4AAHdEaHIS+55zjGcCAMAtEZqcJOMUyw0AAODOCE1OkslGvQAAuDVCkxMUl9h0+PTPe87RPQcAgFsiNDnBsR/zVVhik5+XVS2b+pldDgAAqAWEJie4cuachwcz5wAAcEeEJifIZCVwAADcHqHJCTJ+3qi3HTPnAABwW4QmJ8hg5hwAAG6P0FRDJTaD7jkAABoAQlMNnTh7QQXFNnl7eqhVc3+zywEAALWE0FRDh7PzJUnRIY1kZeYcAABui9BUQ6WLWtI1BwCAeyM01dDhbEITAAANAaGpho6UPmliuQEAANwaoamGDp8p3XOO5QYAAHBnhKYaulBok5fVojZBzJwDAMCdEZqcICo4QF5WfpQAALgzftM7ASuBAwDg/ghNTtCOmXMAALg9QpMTMHMOAAD3R2hyArrnAABwf4SmGrJ6WBQZzMw5AADcHaGphlo185WPp9XsMgAAQC0jNNVQVHCA2SUAAIA6QGiqobYhhCYAABoCQlMNtQ0iNAEA0BAQmmqIJ00AADQMhKYaimTPOQAAGgRCUw35ejFzDgCAhoDQBAAAUAmEJgAAgEogNAEAAFQCoQkAAKASCE0AAACVQGgCAACoBEITAABAJRCaAAAAKoHQBAAAUAmEJgAAgEogNAEAAFQCoQkAAKASCE0AAACVQGgCAACoBEITAABAJXiaXYCrMgxDknTu3Dl5eXmZXI1zFRUVKT8/X7m5ubTNhdA21+TObZPcu320zTWdO3dO0uXf41VBaKqmM2fOSJKioqJMrgQAAFTVmTNn1KRJkypdQ2iqpubNm0uSjh07VuUfen2Xm5urVq1a6bvvvlPjxo3NLsepaJtrom2uy53bR9tc09mzZ9W6dWv77/GqIDRVk4fHpeFgTZo0cbu/UKUaN25M21wQbXNN7tw2yb3bR9tcU+nv8SpdUwt1AAAAuB1CEwAAQCUQmqrJx8dHSUlJ8vHxMbsUp6Ntrom2uSZ3bpvk3u2jba6pJm2zGNWZcwcAANDA8KQJAACgEghNAAAAlUBoAgAAqARCEwAAQCUQmqph8eLFioyMlK+vr2JiYrRz506zS3KKTz75RLGxsYqIiJDFYtHatWvNLslpFi5cqO7duyswMFChoaEaNmyYDhw4YHZZTrFkyRJdd9119kXoevbsqY8++sjssmrFM888I4vFoscee8zsUmrsqaeeksVicXhdddVVZpflNMePH9ef/vQnBQUFyc/PT506ddKnn35qdlk1FhkZWebPzWKxaPLkyWaXVmMlJSVKTExUVFSU/Pz8FB0drXnz5lVrj7b66Ny5c3rsscfUpk0b+fn5qVevXtq1a1eV7kFoqqLVq1crISFBSUlJ+uyzz3T99ddr0KBBOnXqlNml1VheXp6uv/56LV682OxSnG7z5s2aPHmytm/frtTUVBUVFWngwIHKy8szu7Qa+93vfqdnnnlGu3fv1qeffqpbbrlFQ4cO1VdffWV2aU61a9cu/f3vf9d1111ndilO07FjR/3www/215YtW8wuySl++ukn9e7dW15eXvroo4/09ddf629/+5uaNWtmdmk1tmvXLoc/s9TUVEnS3XffbXJlNffss89qyZIleumll7R//349++yzeu655/Tiiy+aXZpT3H///UpNTdWbb76pL774QgMHDlT//v11/Pjxyt/EQJX06NHDmDx5sv19SUmJERERYSxcuNDEqpxPkrFmzRqzy6g1p06dMiQZmzdvNruUWtGsWTPj//7v/8wuw2nOnTtntG/f3khNTTVuuukmY8qUKWaXVGNJSUnG9ddfb3YZteIvf/mL0adPH7PLqBNTpkwxoqOjDZvNZnYpNTZkyBBjwoQJDsfuvPNOY8yYMSZV5Dz5+fmG1Wo13n//fYfjN9xwgzFz5sxK34cnTVVQWFio3bt3q3///vZjHh4e6t+/v7Zt22ZiZaiqs2fPSlK1Nmysz0pKSrRq1Srl5eWpZ8+eZpfjNJMnT9aQIUMc/rfnDjIyMhQREaG2bdtqzJgxOnbsmNklOcV7772nbt266e6771ZoaKi6dOmiV1991eyynK6wsFArVqzQhAkTZLFYzC6nxnr16qW0tDQdPHhQkrR3715t2bJFgwcPNrmymisuLlZJSYl8fX0djvv5+VXpCS8b9lZBdna2SkpKFBYW5nA8LCxM33zzjUlVoapsNpsee+wx9e7dW9dee63Z5TjFF198oZ49e+rixYtq1KiR1qxZo2uuucbsspxi1apV+uyzz6o89qC+i4mJ0euvv64OHTrohx9+0Jw5c/SHP/xBX375pQIDA80ur0YOHz6sJUuWKCEhQTNmzNCuXbv06KOPytvbW3FxcWaX5zRr165VTk6O7r33XrNLcYpp06YpNzdXV111laxWq0pKSjR//nyNGTPG7NJqLDAwUD179tS8efN09dVXKywsTG+99Za2bdumdu3aVfo+hCY0OJMnT9aXX37pNuNHJKlDhw7as2ePzp49q3feeUdxcXHavHmzywen7777TlOmTFFqamqZfyG6uiv/9X7dddcpJiZGbdq00T//+U/dd999JlZWczabTd26ddOCBQskSV26dNGXX36ppUuXulVoeu211zR48GBFRESYXYpT/POf/9TKlSuVkpKijh07as+ePXrssccUERHhFn9ub775piZMmKCWLVvKarXqhhtu0KhRo7R79+5K34PQVAXBwcGyWq3KyspyOJ6VlaUWLVqYVBWqIj4+Xu+//74++eQT/e53vzO7HKfx9va2/2upa9eu2rVrl/73f/9Xf//7302urGZ2796tU6dO6YYbbrAfKykp0SeffKKXXnpJBQUFslqtJlboPE2bNtX/+3//T5mZmWaXUmPh4eFlAvvVV1+tf/3rXyZV5HxHjx7Vxo0b9e6775pditM88cQTmjZtmkaOHClJ6tSpk44ePaqFCxe6RWiKjo7W5s2blZeXp9zcXIWHh2vEiBFq27Ztpe/BmKYq8Pb2VteuXZWWlmY/ZrPZlJaW5lbjR9yRYRiKj4/XmjVr9PHHHysqKsrskmqVzWZTQUGB2WXUWL9+/fTFF19oz5499le3bt00ZswY7dmzx20CkySdP39ehw4dUnh4uNml1Fjv3r3LLOlx8OBBtWnTxqSKnG/58uUKDQ3VkCFDzC7FafLz8+Xh4RgLrFarbDabSRXVjoCAAIWHh+unn37Shg0bNHTo0Epfy5OmKkpISFBcXJy6deumHj16KDk5WXl5eRo/frzZpdXY+fPnHf6Ve+TIEe3Zs0fNmzdX69atTays5iZPnqyUlBT9+9//VmBgoE6ePClJatKkifz8/EyurmamT5+uwYMHq3Xr1jp37pxSUlKUnp6uDRs2mF1ajQUGBpYZdxYQEKCgoCCXH4/2+OOPKzY2Vm3atNGJEyeUlJQkq9WqUaNGmV1ajU2dOlW9evXSggULdM8992jnzp165ZVX9Morr5hdmlPYbDYtX75ccXFx8vR0n1+jsbGxmj9/vlq3bq2OHTvq888/16JFizRhwgSzS3OKDRs2yDAMdejQQZmZmXriiSd01VVXVe33t3Mn9TUML774otG6dWvD29vb6NGjh7F9+3azS3KKTZs2GZLKvOLi4swurcbKa5ckY/ny5WaXVmMTJkww2rRpY3h7exshISFGv379jP/85z9ml1Vr3GXJgREjRhjh4eGGt7e30bJlS2PEiBFGZmam2WU5zbp164xrr73W8PHxMa666irjlVdeMbskp9mwYYMhyThw4IDZpThVbm6uMWXKFKN169aGr6+v0bZtW2PmzJlGQUGB2aU5xerVq422bdsa3t7eRosWLYzJkycbOTk5VbqHxTDcZKlPAACAWsSYJgAAgEogNAEAAFQCoQkAAKASCE0AAACVQGgCAACoBEITAABAJRCaAAAAKoHQBABOYrFYtHbtWrPLAFBLCE0A3MK9994ri8VS5nXrrbeaXRoAN+E+m+YAaPBuvfVWLV++3OGYj4+PSdUAcDc8aQLgNnx8fNSiRQuHV7NmzSRd6jpbsmSJBg8eLD8/P7Vt21bvvPOOw/VffPGFbrnlFvn5+SkoKEiTJk3S+fPnHc5ZtmyZOnbsKB8fH4WHhys+Pt7h8+zsbP3xj3+Uv7+/2rdvr/fee692Gw2gzhCaADQYiYmJGj58uPbu3asxY8Zo5MiR2r9/vyQpLy9PgwYNUrNmzbRr1y69/fbb2rhxo0MoWrJkiSZPnqxJkybpiy++0Hvvvad27do5fMecOXN0zz33aN++fbrttts0ZswY/fjjj3XaTgC1pFa2EgaAOhYXF2dYrVYjICDA4TV//nzDMAxDkvHggw86XBMTE2M89NBDhmEYxiuvvGI0a9bMOH/+vP3zDz74wPDw8DBOnjxpGIZhREREGDNnzqywBknGrFmz7O/Pnz9vSDI++ugjp7UTgHkY0wTAbfTt21dLlixxONa8eXP7f/fs2dPhs549e2rPnj2SpP379+v6669XQECA/fPevXvLZrPpwIEDslgsOnHihPr16/erNVx33XX2/w4ICFDjxo116tSp6jYJQD1CaALgNgICAsp0lzmLn59fpc7z8vJyeG+xWGSz2WqjJAB1jDFNABqM7du3l3l/9dVXS5Kuvvpq7d27V3l5efbP//vf/8rDw0MdOnRQYGCgIiMjlZaWVqc1A6g/eNIEwG0UFBTo5MmTDsc8PT0VHBwsSXr77bfVrVs39enTRytXrtTOnTv12muvSZLGjBmjpKQkxcXF6amnntLp06f1yCOPaOzYsQoLC5MkPfXUU3rwwQcVGhqqwYMH69y5c/rvf/+rRx55pG4bCsAUhCYAbmP9+vUKDw93ONahQwd98803ki7NbFu1apUefvhhhYeH66233tI111wjSfL399eGDRs0ZcoUde/eXf7+/ho+fLgWLVpkv1dcXJwuXryo559/Xo8//riCg4N111131V0DAZjKYhiGYXYRAFDbLBaL1qxZo2HDhpldCgAXxZgmAACASiA0AQAAVAJjmgA0CIxEAFBTPGkCAACoBEITAABAJRCaAAAAKoHQBAAAUAmEJgAAgEogNAEAAFQCoQkAAKASCE0AAACVQGgCAACohP8PwGfIWLh/GZYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Training Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.grid(True)\n",
    "plt.autoscale(axis='x', tight=True)\n",
    "plt.plot(acc_list_epoch)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **(Painters) 8 - Rodando a rede nos dados de validação**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_todas_painters = pd.read_csv(os.path.join(path_dir, \"deep_learning/painters/todas_painters.csv\"), low_memory=False)\n",
    "df_todas_painters = df_todas_painters.reset_index()  \n",
    "df_todas_painters = df_todas_painters.drop(df_todas_painters.index[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df_todas_painters = df_todas_painters.astype(np.float32)\n",
    "X_validation_tensor = torch.tensor(new_df_todas_painters.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([44033, 2049])\n"
     ]
    }
   ],
   "source": [
    "print(X_validation_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0]),\n",
       " tensor([0, 0, 0,  ..., 0, 0, 0])]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicts = []\n",
    "batch_size = 2049\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    correct_sum = 0\n",
    "    for i in range(int(np.floor(total_step/batch_size))): # split data into batches\n",
    "        validationXT_seg = X_validation_tensor[i*batch_size:(i+1)*batch_size]\n",
    "        outputs = model(validationXT_seg)\n",
    "        total = validationXT_seg.size(0)\n",
    "        _, predicted = torch.max(outputs, -1)\n",
    "        predicts.append(predicted)\n",
    "\n",
    "predicts[:5]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}