Structure_project1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Structure project1.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nxf-emma/APS360-Artificial-Intelligence-Fundamentals/blob/main/Structure_project1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#mount googledrive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "id": "9YmzNJngAsK5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8c6359d-9cf2-4f5d-8636-ea1368e52ea3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ihbRrhOPrlrl"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "import os\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "from torchvision import datasets, models, transforms\n",
        "from torch.utils.data.sampler import SubsetRandomSampler"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "img_size = 48 "
      ],
      "metadata": {
        "id": "CW1MxNmaBNS3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Convolutional Neural Network Architecture\n",
        "class CNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        self.pool = nn.MaxPool2d(2, 2) #kernel_size, stride \n",
        "\n",
        "        self.conv1 = nn.Conv2d(3, 5, 3, padding = 2) #in_channels, out_chanels, kernel_size\n",
        "        self.conv2 = nn.Conv2d(5, 25, 3) #in_channels, out_chanels, kernel_size\n",
        "        self.conv3 = nn.Conv2d(25, 50, 3)\n",
        "        self.conv4 = nn.Conv2d(50, 100, 3)\n",
        "        \n",
        "        self.fc1 = nn.Linear(100*1*1, 70) #chanels*dimension\n",
        "        self.fc3 = nn.Linear(70, 32)\n",
        "        self.fc2 = nn.Linear(32, 7) #last output channel always = 7\n",
        "        self.dropout = nn.Dropout(0.4)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        # 25x25\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        # 11\n",
        "        x = self.pool(F.relu(self.conv3(x)))\n",
        "        # 4\n",
        "        x = self.pool(F.relu(self.conv4(x)))\n",
        "        # 1\n",
        "\n",
        "\n",
        "        x = x.view(-1, 100*1*1)\n",
        "        x = F.relu(self.dropout(self.fc1(x)))\n",
        "        x = F.relu(self.dropout(self.fc3(x)))\n",
        "        x = self.fc2(x)\n",
        "        x = x.squeeze(1)\n",
        "        return x"
      ],
      "metadata": {
        "id": "U4pkyLBiApwZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_accuracy(model, dataloader):\n",
        "    \n",
        "\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for imgs, labels in dataloader:\n",
        "        \n",
        "        if use_cuda and torch.cuda.is_available():\n",
        "            imgs = imgs.cuda()\n",
        "            labels = labels.cuda()\n",
        "\n",
        "        output = model(imgs)\n",
        "        \n",
        "        #select index with maximum prediction score\n",
        "        pred = output.max(1, keepdim=True)[1]\n",
        "        correct += pred.eq(labels.view_as(pred)).sum().item()\n",
        "        total += imgs.shape[0]\n",
        "    return correct / total"
      ],
      "metadata": {
        "id": "CX0EUse3A1nB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train(model, train_data, val_data, batch_size=3000, num_epochs=5, lr = 0.01):\n",
        "    \n",
        "    num_workers = 1\n",
        "    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, \n",
        "                                           num_workers=num_workers, shuffle=True)\n",
        "    val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, \n",
        "                                          num_workers=num_workers, shuffle=True)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=lr)\n",
        "\n",
        "    iters, losses, train_acc, val_acc = [], [], [], []\n",
        "\n",
        "    # training\n",
        "    n = 0 # the number of iterations\n",
        "    for epoch in range(num_epochs):\n",
        "        print(\"Epoch\", epoch)\n",
        "        n = 0\n",
        "        for imgs, labels in iter(train_loader):\n",
        "            print(\"iteration \", n)\n",
        "\n",
        "            if use_cuda and torch.cuda.is_available():\n",
        "                imgs = imgs.cuda()\n",
        "                labels = labels.cuda()\n",
        "\n",
        "            out = model(imgs)             # forward pass\n",
        "\n",
        "            loss = criterion(out, labels) # compute the total loss\n",
        "            loss.backward()               # backward pass (compute parameter updates)\n",
        "            optimizer.step()              # make the updates for each parameter\n",
        "            optimizer.zero_grad()         # a clean up step for PyTorch\n",
        "            n += 1\n",
        "\n",
        "        # save the current training information\n",
        "        iters.append(epoch)\n",
        "        losses.append(float(loss)/batch_size)             # compute *average* loss\n",
        "        # calculate accuracy at each epoch instead of iteration\n",
        "        # def get_accuracy(model, data):\n",
        "        train_acc.append(get_accuracy(model, train_loader)) # compute training accuracy \n",
        "        # compute validation acc every epoch\n",
        "        val_acc.append(get_accuracy(model, val_loader))  # compute validation accuracy\n",
        "        print(\"Epoch: \", epoch, \" Validation Accuracy: \", val_acc[epoch])\n",
        "\n",
        "            \n",
        "\n",
        "    # plotting\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, losses, label=\"Train\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.show()\n",
        "\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, train_acc, label=\"Train\")\n",
        "    plt.plot(iters, val_acc, label=\"Validation\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Training Accuracy\")\n",
        "    plt.legend(loc='best')\n",
        "    plt.show()\n",
        "\n",
        "    print(\"Final Training Accuracy: {}\".format(train_acc[-1]))\n",
        "    print(\"Final Validation Accuracy: {}\".format(val_acc[-1]))"
      ],
      "metadata": {
        "id": "PWPxMA3gA2Gi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/FER-2013_final/train'\n",
        "val_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/FER-2013_final/val'\n",
        "test_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/FER-2013_final/test'\n",
        "\n",
        "train_data = datasets.DatasetFolder(train_path, loader=torch.load, extensions=('.tensor'))\n",
        "val_data = datasets.DatasetFolder(val_path, loader=torch.load, extensions=('.tensor'))\n",
        "test_data = datasets.DatasetFolder(test_path, loader=torch.load, extensions=('.tensor'))"
      ],
      "metadata": {
        "id": "8TP_4QGdEdVr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#train\n",
        "model = CNN()\n",
        "use_cuda = True\n",
        "model.cuda()\n",
        "\n",
        "train(model, train_data, val_data, lr=0.1)"
      ],
      "metadata": {
        "id": "uQ_udpVWA72X",
        "outputId": "f99610b4-2caf-41a7-c086-9f054df22f81",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch 1\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch 2\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch 3\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch 4\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-7-b290c2e59828>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-5-bc43001cf607>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(model, train_data, val_data, batch_size, num_epochs, lr)\u001b[0m\n\u001b[1;32m     39\u001b[0m     \u001b[0;31m# compute validation acc every epoch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m     \u001b[0mval_acc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_accuracy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# compute validation accuracy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Epoch: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\" Validation Accuracy: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval_acc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mepoch\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: list index out of range"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "val_loader = torch.utils.data.DataLoader(val_data, batch_size=3000, \n",
        "                                          num_workers=1, shuffle=True)\n",
        "get_accuracy(model, val_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zqRvqQuqC9Sx",
        "outputId": "6e01b2bf-85bb-466d-eddb-56501fefd85c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.1744218445249373"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_loader = torch.utils.data.DataLoader(train_data, batch_size=3000, \n",
        "                                          num_workers=1, shuffle=True)\n",
        "get_accuracy(model, train_loader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UKzGm39tDevf",
        "outputId": "2aa7b79c-d960-432c-b6de-08105b8c40ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.149128869166697"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#train\n",
        "model2 = CNN()\n",
        "use_cuda = True\n",
        "model2.cuda()\n",
        "\n",
        "train(model2, train_data, val_data, lr=0.45)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "YT3ZRYabD8Gd",
        "outputId": "28974a42-d67a-48d5-bc84-a3943a775e68"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  0  Validation Accuracy:  0.24240735580941766\n",
            "Epoch 1\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  1  Validation Accuracy:  0.015324602953468934\n",
            "Epoch 2\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  2  Validation Accuracy:  0.1156310950125383\n",
            "Epoch 3\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  3  Validation Accuracy:  0.2449150181108944\n",
            "Epoch 4\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  4  Validation Accuracy:  0.015881861242685986\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3yV9fXA8c9JIAkjYe+wlI2MRMCBi7pQERyggAToVmvVWuvPWltx9Werbf21tY7WOlHcCIqiouJWwl6CgIhhGZlhZ5zfH98nIQk3yQ259z53nPfrdV+54xmHS27Ofb7riKpijDHGVJbkdwDGGGOikyUIY4wxAVmCMMYYE5AlCGOMMQFZgjDGGBOQJQhjjDEBWYIwCU9E3hCRSaHe1phYJzYPwsQiEdlT7mFD4CBQ7D3+uapOjXxUdSMiGcAdwCVAc2ArMBO4S1W/9zM2k5jsCsLEJFVtXHoDNgAXlnuuLDmISD3/ogyeiKQAc4C+wHAgAzgJ2AYMOYrjxcS/20Q3SxAmrojIGSKSJyL/IyJbgMdEpJmIvCYi+SKyw7ufWW6f90XkJ979ySLykYjc5237tYicd5TbdhWRD0SkQETeEZEHROTpKkKfCHQCLlbVFapaoqrfqeqdqjrLO56KSLdyx39cRO6q5t+9UkRGlNu+nvceZHuPTxSRT0Rkp4gsFpEz6vr+m/hiCcLEo7a4JprOwM9wv+ePeY87AfuBf1az/wnAKqAl8GfgURGRo9j2GeALoAUwBcip5pxnAW+q6p5qtqlJ5X/3s8C4cq+fC3yvqgtEpAPwOnCXt8+NwEsi0qoO5zdxxhKEiUclwG2qelBV96vqNlV9SVX3qWoBcDdwejX7f6Oq/1bVYuAJoB3QpjbbikgnYDDwB1U9pKofATOqOWcLYHPt/plHqPDvxiWokSLS0Ht9PC5pAEwAZqnqLO9q5W0gFzi/jjGYOGIJwsSjfFU9UPpARBqKyMMi8o2I7AY+AJqKSHIV+28pvaOq+7y7jWu5bXtge7nnAL6tJuZtuORSFxX+3aq6BlgJXOgliZG4pAHuKmOM17y0U0R2AqeEIAYTR6wjy8SjykPzfg30BE5Q1S0iMhBYCFTVbBQKm4HmItKwXJLoWM327wB3iUgjVd1bxTb7cCO2SrUF8so9DjQksbSZKQlY4SUNcMnqKVX9aQ3/DpPA7ArCJIJ0XL/DThFpDtwW7hOq6je4JpspIpIiIicBF1azy1O4P9oviUgvEUkSkRYicouIlDb7LALGi0iyiAyn+mayUtOAc4CrOHz1APA07sriXO94aV5Hd2bAo5iEZAnCJIL7gQbA98BnwJsROu8VHB6qehfwHG6+xhFU9SCuo/pL4G1gN66DuyXwubfZdbgks9M79vSaAlDVzcCnwMne+Uuf/xYYBdwC5OOS02+wvwmmHJsoZ0yEiMhzwJeqGvYrGGNCwb4tGBMmIjJYRI71mouG476x1/it35hoYZ3UxoRPW+Bl3BDWPOAqVV3ob0jGBM+amIwxxgRkTUzGGGMCipsmppYtW2qXLl38DsMYY2LK/Pnzv1fVgEusxE2C6NKlC7m5uX6HYYwxMUVEvqnqNWtiMsYYE1BYE4SIDBeRVSKyRkRuDvD6DSKyQkSWiMgcEelc7rViEVnk3apb5MwYY0wYhK2JyVsI7QHgbNwQv3kiMkNVV5TbbCEwSFX3ichVuOWSL/de26+qA8MVnzHGmOqF8wpiCLBGVdep6iHcmjCjym+gqu+VW8jsM8DWgTHGmCgRzgTRgYrLG+d5z1Xlx8Ab5R6niUiuiHwmIhcF2kFEfuZtk5ufn1/3iI0xxpSJilFMIjIBGETF1Sk7q+pGETkGeFdElqrq2vL7qeojwCMAgwYNshl/xhgTQuG8gthIxfXvM73nKhCRs4DfASO9FS0BUNWN3s91wPtAVhhjNcYYU0k4E8Q8oLtXuD0FGEulkosikgU8jEsO35V7vpmIpHr3WwJDgfKd28aYeLVmDmyc73cUhjA2MalqkYhcA8wGkoH/qupyEbkDyFXVGcC9uPKML3h13jeo6kigN/CwiJTgktg9lUY/GWPi0dbl8OxYaNoZrpkHEs6if6YmYe2DUNVZwKxKz/2h3P2zqtjvE6BfOGMrU3QQvnwNModA0+oqQhpjwqroELz8cygpgm1fwbefQ6cT/Y4qodlM6j3fwYs/hgVP+h2JMYlt7p9g61K4+BFIaQwLnvI7ooRnCaJpR+h2JiyaCiXFfkdjTGLKy4WP/goDr4D+Y6DvxbD8FThY4HdkCc0SBED2RNi9Eda+63ckxiSeQ/vglZ9DRgcY/r/uueyJULjXJQnjG0sQAD3Og4YtYcETfkdiTOKZcztsWwOjHoC0Ju65zMHQsoc1M/nMEgRAvRQYMBZWvQF7bEa2MRGzbi58/hAM+TkcU26erAhk5UDeF5C/yr/4EpwliFLZE93oicXP+h2JMYnhwC549RfQohucNeXI1weMg6R6sNCuIvxiCaJUq57Q8QQ3msnqdBsTfm/e4vr+LnoIUhoe+XrjVtBjOCyeBsWFkY/PWIKoIHvi4fHXxpjwWfUGLHoaTvkVdBxc9XZZObA3H1a/GbnYTBlLEOX1uQhS0m1OhDHhtHcbzLgW2vSD04+oI1ZRt7OgcVvrrPaJJYjyUhvDcZe4oXUHdvsdjTHxRxVe/xXs3wEXP+QGiFQnuR4MHA9r3obdmyIToyljCaKy7ElQuA+WveR3JMbEn6UvwopXYdgt0Pa44PbJmgBaYgNIfGAJorIO2dC6jzUzGRNquzfBrF+7dc+GXhf8fi2Ohc6nwMKnbQBJhFmCqEzEdVZvWgBblvkdjTHxQRVm/NKNRrr4IUhKrt3+WRNg+zr45uPwxGcCsgQRSP/LITnFxl8bEyrzH4M178DZd7grgtrqMwpSM6yzOsIsQQTSsDn0GuHGXxce8DsaY2Lb9nUw+1Y45gwY9OOjO0ZKQzjuUtd/cWBXKKMz1bAEUZXsiXBgp6sVYYw5OiXFMP1qNyN61AOQVIc/Odk5ULTfBpBEkCWIqnQ9HZp2ss5qY+ri0wdgw6dw3p+gSWbdjtW+dACJNTNFiiWIqiQluVmcX8+F7V/7HY0xsee7lfDuna65dsDYuh+vdAG/TQtcaVITdpYgqjNwPEiSKyZkjAlecaGr8ZCaASPuD11t6f6XQ1J9u4qIEEsQ1WmSCceeCQunQnGR39EYEzs+uBc2L4YL73eL7oVKoxbQ6wJY8pyrJ2/CyhJETbInQsEmWDvH70iMiQ0b58MH90H/sdD7wtAfPzsH9m+HVbNCf2xTgSWImvQYDo1aWWe1McEo3A+vXAnpbV3HdDgcMwwyMq2ZKQIsQdSktNrc6jehYKvf0RgT3ebcCd+vhlH/hAZNw3OOpGTXP7j2Xdj5bXjOYQBLEMHJsmpzxtRo/Ufw2b9g8E/g2B+E91xZVwBqn8kwswQRjFY9oNNJbukNWyzMmCMdLIDpV0Hzrm45jXBr1sXNVVr4FJSUhP98CcoSRLCycmDbGjfpxxhT0exbYFeeVz60UWTOmT0Rdm6A9R9E5nwJyBJEsPqWVpuzjjFjKlg92w3iOPla6HRC5M7b6wJIa2KfyTCyBBGslEbQb7RXbc4WCzMGgH3b3TLerfu6IkCRVL8B9LsMVs50FepMyFmCqI3SxcKWvuh3JMZEh9d/7ZLExQ9BvdTInz87B4oP2mcyTCxB1Eb7bGhznNWJMAbcqqrLX4Yz/gfa9fcnhnYDoG1/m6cUJpYgaqNssbCFsHmJ39EY45+CLe7qocMgGPorf2PJyoEtS9zSHiakLEHUVv/LIDnVriJM4iotH1p4wDUtJdfzN57+Y9xn0jqrQ84SRG01bO7Wl1nynFtWwJhEs+BJ+OotOGsKtOzudzTQoJn7TC593ipAhpgliKORneNGMq20anMmwexY7+Y8dDkVhvzM72gOK/1MWgXIkAprghCR4SKySkTWiMjNAV6/QURWiMgSEZkjIp3LvTZJRL7ybpPCGWetdTkNmnaGBU/4HYkxkVNSAtN/AQhc9K+6lQ8NtS6nWQXIMAjb/7CIJAMPAOcBfYBxItKn0mYLgUGq2h94Efizt29z4DbgBGAIcJuINAtXrLWWlOS+saz/0BVkNyYRfP4gfPMRnHeP+2McTZKSYOAEVwFyx3q/o4kb4fwKMARYo6rrVPUQMA0YVX4DVX1PVfd5Dz8DSovWngu8rarbVXUH8DYwPIyx1t7AK1y1uYVP+x2JMeGXvwreuR16nOd+96PRwPGAuAJfJiTCmSA6AOXX4s3znqvKj4E3arOviPxMRHJFJDc/P7+O4dZSRnvodjYsesaqzZn4Vlo+NKURXPh/oSsfGmpNO7pVZBc9AyXFfkcTF6KiEVFEJgCDgHtrs5+qPqKqg1R1UKtWISxrGKzsiVCwGda8E/lzGxMpH/7Vzf0Z8TdIb+N3NNXLzoHdebDuPb8jiQvhTBAbgY7lHmd6z1UgImcBvwNGqurB2uzrux7nQqPW1jFm4temhfDBn6HfGLdgZbTreT40aG5zIkIknAliHtBdRLqKSAowFphRfgMRyQIexiWH78q9NBs4R0SaeZ3T53jPRZfk+jBwnFWbM/Gp8IArH9qoFZxfq4t7/9RLhf6Xw5evw95tfkcT88KWIFS1CLgG94d9JfC8qi4XkTtEZKS32b1AY+AFEVkkIjO8fbcDd+KSzDzgDu+56JOVA1oMi5/xOxJjQuu9uyD/Sxj5TzcZLVZk50BJoZvMaupENE4qpA0aNEhzc3P9Ofl/z4M9W+GX86O3A8+Y2vjmE3jsfDh+Mlx4v9/R1N4jw6DoIFz1sX0mayAi81V1UKDXoqKTOuZlT4Tta92HyphYd3CPKx/arDOcc5ff0Ryd7Bz4bjlsWuB3JDHNEkQo9BkFqRnWWW3iw1u3wo5v4KIHIbWx39EcneMuhXoNrLO6jixBhEJKQ1dtbsWrsH+n39EYc/S+egfmPwYnXwOdT/Y7mqOX1sR9cVv2EhzaV/P2JiBLEKGSPdFVm1tmla1MjNq/A2ZcA616w7Bb/Y6m7rJz4OBuWDmj5m1NQJYgQqXdQGjTz5qZTOya9RvYm+9qPNRP8zuauus8FJofY81MdWAJIlRE3FXE5sVW2crEnuXTYekLcNpN0H6g39GEhghkTXALDG5b63c0MckSRChZZSsTiwq2wmu/gvZZcOoNfkcTWgPG2aKadWAJIpQaNIM+I2HJ81ZtzsQGVZh5HRzaCxc/7FYHiCe2qGadWIIIteyJcHAXrJzpdyTG1GzRVFj9Bpx1G7Tq6Xc04ZGdA3u2wNo5fkcScyxBhFrnU6BZF+usNtFv5wZ442b3O3vCVX5HEz49hrv1pOwzWWuWIEItKcmtz7T+Q+sYM9GrpASmXw0oXPRAdJUPDbXk+m4Bv9Vvwp7vat7elKnxt0JEWkQikLhi1eZMtPviEfcl5tw/uiveeJc9EUqKYPE0vyOJKcF8bfhMRF4QkfNFbNWroGS0g+7nWMeYiU7ffwXv3Abdz3V/OBNBq56QOcR9aYuTBUojIZgE0QN4BMgBvhKRP4pIj/CGFQeyJ7qOsTVv+x2JMYcVF7kaD/UbwMi/J9ZKp9k58P0qyJvndyQxo8YEoc7bqjoO+CkwCfhCROaKyElhjzBWdT8HGrexjjETXT6+HzbmwgV/gfS2fkcTWX0vhvqN7DNZC0H1QYjIdSKSC9wI/BJoCfwasCo5VUmu7ybprJ4NBVv8jsYY2LIU3r8H+l7iVjtNNKnpLkksf8UtaW5qFEwT06dABnCRql6gqi+rapGq5gIPhTe8GJc90VWbW2R51Pis6CC8/HNo2NxdPSSq7Bw4tMclCVOjYBJET1W9U1XzKr+gqn8KQ0zxo8WxbsGwBU9ax5jx1/v/6wrojPynSxKJquMJ0KK7jTAMUjAJ4i0RaVr6QESaicjsMMYUX7Inwo6vYf1HfkdiEtWGz+Hj/3O/iz3O8Tsaf4m4q4hvP4P81X5HE/WCSRCtVLWsCo6q7gBahy+kONN7JKQ2gYW2gJ/xwaG9MP1KaJLp5jwY6D8WJNk+k0EIJkEUi0in0gci0hmw9pJgVag2t8PvaEyiefs22P61Vz403e9ookN6G7f8xuJnobjQ72iiWjAJ4nfARyLylIg8DXwA/Da8YcWZ7IlQdACWWrU5E0Fr34N5/4YTr4Yup/gdTXTJznHFkb56y+9Iolow8yDeBLKB54BpwPGqan0QtdF+ILTtb+OvTeTs3wmv/gJa9oQzf+93NNGn29nQuK3VbqlBsCt0FQPfAbuBPiJyWvhCilPZE2HLEti0yO9ITCJ482Y3/+bih9ysaVNRcj0YOM5dQdg8pSoFM1HuJ7hmpdnA7d7PKeENKw71Gw310qxjzITfytdc+/ppN0KHbL+jiV4DJ9g8pRoEcwVxHTAY+EZVhwFZwM7qdzFHaNDMjWha8gIc2ud3NCZe7cl3FeLaDYDTfuN3NNGtZTfodLIt4FeNYBLEAVU9ACAiqar6JRCnpafCrKza3Ay/IzHxSBVeux4OFsRn+dBwyM6B7Wthw6d+RxKVgkkQed5EuenA2yLyKvBNeMOKU11OgebHWMeYCY8lz8GXr8EPboXWvf2OJjb0GQUp6faZrEIwo5guVtWdqjoF+D3wKHBRuAOLSyKQNQG++Qi+X+N3NCae7MqDWTe5JpOTfuF3NLEjpRH0uxRWTIcDu/2OJupUmyBEJFlEvix9rKpzVXWGqh4Kf2hxasB4m8VpQksVXr3GVUy76F+QlOx3RLElKwcK98Gyl/yOJOpUmyBUtRhYVX4mtamjjHbQ41ybxWlCZ95/YN17cO5d0Lyr39HEng7HQ6vetoBfAMH0QTQDlovIHBGZUXoLd2BxLSsH9my1WZym7rathbf/AN3OguN/6Hc0sal0Ab+NufDdSr+jiSr1gtjGpmGGWvdzvFmcT0KvC/yOxsSqkmKYfpUbrTTyH4lVPjTU+l/u1q1a8BQMt0UNS9WYIFR1biQCSSjJ9WDgeFf+cfcmyGjvd0QmFn3yd/j2c7jkP/Y7VFeNWkLP82DJNDhrCtRL8TuiqBDMTOoCEdnt3Q6ISLGIBNXdLyLDRWSViKwRkZsDvH6aiCwQkSIRGV3ptWIRWeTd4q9JK2sCaInN4jRHZ+tyeO+Pbphmv9E1b29qlj0R9m2DVbP8jiRqBDPMNV1VM1Q1A2gAXAr8q6b9RCQZeAA4D+gDjBORPpU22wBMJnBt6/2qOtC7jazpfDGnxbHQ5VTXMVZS4nc0JpYUHXLlQ9OawgV/s6alUDn2B5DRwTqrywl2sT4A1JkOnBvE5kOANaq6zhsWOw0YVel461V1CZCYfyGzcly1uW+s2pyphbl/gq1LYeTfoVELv6OJH0nJrul37RzYtdHvaKJCME1Ml5S7jRaRe4ADQRy7A/Btucd53nPBShORXBH5TEQCTswTkZ952+Tm5+fX4tBRoo9Xbc6WATfBysuFj/7qFprreZ7f0cSfgVdY0285wVxBXFjudi5QQKUrgTDprKqDgPHA/SJybOUNVPURVR2kqoNatWoVgZBCrH4D6H8ZrJhh1eZMzQ7tg1d+7ppBhv+v39HEp+Zdvabfp6zpl+BGMR3t4OqNQMdyjzO954Kiqhu9n+tE5H3cKrJrjzKWKh0qKuGTtd8DIF5brnC4WVeQcvcpuyPeI5HDz5ftX+G5w3uWP07ptg3bX0SPef9m4wdPsL3vDytsd/hYlfav8vyHAwx0rvLbVT5mxeNLtduKQItGqSQnWdt3RM25HbatgUkzIS3D72jiV/ZEePmnrum3a2KXvqkxQYjIE8B1qrrTe9wM+Iuq/qiGXecB3UWkKy4xjMVdDdTIO8c+VT0oIi2BocCfg9m3tgoOFDL5sXnhOHTQZqZ0Ifnj/3Lhe90ol4aiWoP6yfRql06fdhn0aZ9Bn3YZ9GqbQYMUW+YhLNbNhc8fghOujKs/WqpKfsFBVmzezYrNu1m5uYCVm3ezc19wqwwE2z8fzGalx0rVRrxOQz566l6m1DtyVSEJ4mihjMsdr/ot+7TP4N8TBwV5tOAFM1Guf2lyAFDVHSKSVdNOqlokItfgCgwlA/9V1eUicgeQq6ozRGQw8AputvaFInK7qvYFegMPi0gJrhnsHlVdUft/Xs0yGtTn5atPLrccvJbdVw4vE6/enQrPoe4Jyn6g6j1fdv/I/Sm3vyrUXzOZXvOn8NyIBuxuflzAcxHwmBXPdXifw2vbV4i1dJ8A25Y/TeD4Dx+npET5+vt9rNi8i5mLNzH18w0AJAl0bdmIPu2bVEgcrdJTMXVwYJcrH9qiG5x5m9/RHLXC4hLW5e9lZVkycLfv9xz+I5zZrAG9g/ydCb6EQ80bVj7Wso3nctaO1/m8280cSE6v1Tk1iPMFeyx3vJp1at4wuIPVkmgNUYrIYuAMVd3hPW4OzFXVfmGJ6CgNGjRIc3Nz/Q7j6OzfCX/p6UZQjPib39HUiqqyced+VmxyH/rSn3k79pdt0yo9tULC6NM+gy4tGlkTVbCm/wIWPwM/fhsyQ/8tMRx27S8sSwArNu1m5ZbdrN66h0NFrl0/pV4SPduk09u7Cu3dLoNe7TJo0iBKalhsWgiPnAHn3wdDfup3NGElIvO9/t4jBHMF8RfgUxF5wXs8Brg7VMEZoEFT6HMRLH0RzrkbUsLzbSAcRITMZg3JbNaQc/q2LXt+175CVm7ZXSFx/OfDdRQWuy8k1kQVpFVvwKKn4dQbozI5lJQoeTv2s2LzLlZ4zUMrNu1m487DXxBaNk6hd7sMfnhyF3p7/9/HtGxEveRajbKPrHYDoU0/11kd5wmiOjVeQQB4E9x+4D18N1zNPXUR01cQAOs/hsfPh4secsXU49ChohLWfLenLGEs37SLFZt3U3CgCLAmqiPs3Qb/OhHS28BP3vV9+YcDhcWs2lJQoXlo5eYC9hw8/P93TKvGLgm0y3BXB+0zaJ2e5mvcR+3zh+GNm+DnH0K7/n5HEzbVXUEE08R0IrBcVQu8xxlAb1X9POSR1kHMJwhV+Mfx0LgN/OgNv6OJGNXSb6AVrzbKfwNtnZ5aoXmqTzvXRJUUz01UqvDCJHcF8bP3oU3fCJ46cMfxuvw9lHh/Lhqn1qN3u/RyySCDnm3TSasfR1eA+7bDX3rB8ZPh/LCMkYkKdW1iehDILvd4T4DnTF2VLjn8zhRXba5lN78jiggRoWPzhnRs3pBzKzVRlf6BKk0cH321jiLvL1TDlGR6tU33EkYT+rTPoGeb9Phpolr6Iqx41S0cF8bkUL7juHzncfmO4w5NG9CnfQbn92vnknS7DDKbNYjvBA3QsDn0HuFKuZ59B9SP0SuhOgjmCmKRqg6s9NwSVY2qa66Yv4IAKNgKf+0NJ1/jfiFNBQeLil0TVaUO8fJNVMe0anxEh3jLxjHWRLV7k2taatULfvhGyCrEle84Lk0GlTuOe7RpXHZF0CfaOo79sPZdeOpiuPTRuF0Usa5XEOtE5FrcVQPA1cC6UAVnyklvAz2Gu2n+P/i9W+fflEmtl0zf9k3o275J2XOVm6iWb9rN/G92MGPxprJtKjdR9W3fhM7NG0bnN2BVmPFLV23wogePKjkE03HcolEKfdof7jju3S6DY1o1on40dxz7oesZ0KST66yO0wRRnWASxJXA34FbcUNy5wCJ260fbtkTYdXrsHq2u7w11aqqiWrnvkNH9Gt89NX3FZqoSr8llyaPqGhDn/8YrHnHDa9sccTqMkco7TiuOLfgyI7j7M7NmHBi57Jhpa3SU2ucfGWApCTIugLevwd2fAPNOvsdUUQFNYqpwg4iDYARqvpCjRtHUFw0MQEUF8Hf+kK7AXDF835HE1cOFhXz1dY9FRLHyk27KSj3x/TYVo2P6BBvEakmqu3r4MFToOMQyHmlwnTc8h3HKzcfHklUVcdxafLrEU/9Mn7Z+S3c3w9O/x8Y9lu/owm5ujYxldZ2OBcYB5wNfAREVYKIG8n13DeWj/5m1eZCLLVeMsd1aMJxHY5solpe7kojd/0OXl10uImqTUb5iX6uQzzkTVQlxTD9akiqR+GF/2Dd1j01dhz3blfacZxOn3ZNEqPj2A9NO8Kxw2DRVDj9ppD1CcWCahOEiJyOWz/pfOAL3JpIx6jqvgjElriyJsCHf3G/kKf9xu9o4lr5Jqrhxx1uotqx91DZH+fSq40PvvqeYu/reqOUZHqFoIlq1/5Cvty8m6RP/8HgDZ/yl8Y38PBflh3uOE5Ookfbxgzr2Zo+7d2VQe+2GTRpaP1TEZU1AV78Eax7H7qd6Xc0EVNlE5OI5OEqvj0ITFfVAhH5WlW7RjLAYMVNE1Opx0fAzg1w7SLXDmp8d6Aw8CiqPVU0UfVt34Te7dJp0Ti12o7j7pLHaym38LFk81jmnfT2Jgpax3EUKTrolsM5ZhiMeczvaELqaJuYXgQuAi4HikXkVYJbN8qEQvYkePknsP4DOOYMv6MxQFr9I5uoKvzh9xLGvK+3V2iiap2eyr5DxRUSSdeWjcju3IycIe24Yund1D/QhGG/eIYfNI7BuiaJoF4q9L8ccv/rJtA1bO53RBFRZYJQ1etF5FfAGbi+hz8DTUTkMmCWqu6JTIgJqvcISGsCC56yBBHFkpKETi0a0qlFQ4Yf167s+QpNVJt3ex3I3ozj8h3H7/0RdiyHy6eCJYfoljXBLbm+5Hk48Uq/o4mIavsg1LU/vQe8JyL1OdxR/S+gZfjDS2D1G7hvLPOfSKhvLPGiWaMUTu7WkpO7VfMx2TgfPrgPBoyzIc2xoG0/t4jfwqfghJ8HX/QhhgXduKmqhar6mqpeQcVKcSZcsidC8UFYagPG4k7hfnjlSkhvC8Pv8TsaE6zsHNi6zC0HngCOqvdLVffXvJWps9JvLPOfqE11FBML5twJ36+GUQ+45d5NbDhuNNRLg4VP+x1JRNjwiGiXPRG+Ww6bFvgdiQmV9R/BZ/+CwT914+tN7GjQFPqMcospFsb/92RLENGu32io18B1VpvYd7AApl8FzbvC2bf7HY05Glk5cHAXrJjhdyRhV+NMahGZyZHDW3cBucDDqnogHIEZT1oT6OtVmzv3bn8VCoIAAB9ZSURBVEhp5HdEpi5m3wK78uBHs+3/MlZ1HgrNurjO6gGX+x1NWAVzBbEOVwPi395tN1AA9PAem3DLngiHCmD5dL8jMXWxejYseBKGXufWWzKxKSnJDXld/6FbPyuOBZMgTlbV8ao607tNAAar6i+wokGR0ekkaNHNfWMxsWnfdreMd5vj4Iz4W/At4Qy8AiQJFk71O5KwCiZBNBaRTqUPvPuNvYeHAu9iQkrEtXtu+BTyV/sdjTkar//aJYmLH3Kzck1sy2gP3c5ytVtKiv2OJmyCSRC/Bj4SkfdE5H3gQ+BGEWkEPBHO4Ew5A8ZBUj27iohFy16C5S/DGTe7ocsmPmRNgIJNsGaO35GETY0JQlVnAd2B64HrgJ6q+rqq7lXV+8MdoPGUVptb/CwU2YVbzPhuJcz8FXQYBEOv9zsaE0o9zoOGLWHhk35HEjbBDnM9HugLDAAuE5GJ4QvJVCl7IuzNh9Vv+h2JCcbuzfD0aLdsypjHXK0PEz/qpcCAsbDqDdj7vd/RhEWNCUJEngLuA04BBnu3gEvDmjA79kxIb2/NTLHgwG6YOgYO7IQrXoCmnWrex8SerBwoKYLF0/yOJCyC+UozCOijta1NakIvuR4MHA8f/dWNpW+S6XdEJpCiQ/B8DuSvhPHPQ7v+fkdkwqV1L8gc7L60nfSLuFvAL5gmpmVA2xq3MpGRNQG0xI2eMNFHFWZe6yqPXfj3hKo+lrCyJkD+l5AXRwXLPMEkiJbAChGZLSIzSm/hDsxUoXlX6Hq6+8ZSUuJ3NKay9/7oBhKccYurLW7iX99LoH7DuGz6DaaJaUq4gzC1lD0RXvoxfD3XFnuLJvMfhw/+7NqlT7/J72hMpKRlQN+LYdnLMPx/42oJlWCGuc4NdItEcKYKvUZAWlO3bIOJDqvfgtducJOnRvwt7tqiTQ2ycuJyOZwqE4SIfOT9LBCR3eVuBSKyO3IhmiPUT3PV5r58zc3ONf7atBBemAxtj4MxT0Byfb8jMpHW6cS4XA6nygShqqd4P9NVNaPcLV1VMyIXogkoeyIUH4Ilz/kdSWLbsR6mXgYNW8D4FyC1cY27mDgk4jqrN3wK33/ldzQhE9REORFJFpH2ItKp9BbuwEwN2h4H7bNdM5ONQPbHvu1uIlzxIZjwopvtbhLXgPEgyXFVbS6YiXK/BLYCbwOve7fXgjm4iAwXkVUiskZEbg7w+mkiskBEikRkdKXXJonIV95tUlD/mkSTnQPfrYCNVm0u4goPwLPjYOcGGPcstOrpd0TGb+ltoMe5bhRbcZHf0YREMFcQpesv9VXVft6txpk/IpIMPACcB/QBxolIn0qbbQAmA89U2rc5cBtwAjAEuE1EmgURa2I5brQbXrfA1kyMqJISePmn8O1ncMnD0PlkvyMy0SIrB/Zsha/e8juSkAgmQXyLqyBXW0OANaq6TlUPAdOAUeU3UNX1qroEqDyg/1zgbVXdrqo7cFcvw48ihvhWNrzuJTi4x+9oEsdbv4OVM+Ccu937b0yp7mdDo9Zx01kdbEW590XktyJyQ+ktiP064JJLqTzvuWAEta+I/ExEckUkNz8/P8hDx5msHDi0B1bE1/C6qPXpA/DZv+CEq9zSCsaUl1wfBo5z1QMLtvodTZ0FkyA24L7BpwDp5W6+U9VHVHWQqg5q1aqV3+H4o9OJ0KK7zYmIhOXTYfbvoPeFrj64zXUwgWTlgBa7vogYV+NMalW9/SiPvRHoWO5xpvdcsPueUWnf948yjvgm4oa8vv17yF9lnaXh8s2n8PLPXC3pS/4NScl+R2SiVcvurkzwwqdc/fEY/iJR3US5+72fM8uvwVSLtZjmAd1FpKuIpABjgWDXcJoNnCMizbzO6XO850wgpdXm7CoiPPJXw7NjoWlHGDfN1XcwpjpZObBtDWz4zO9I6qS6K4jSXpb7jubAqlokItfg/rAnA/9V1eUicgeQq6ozRGQw8ArQDLhQRG73RkttF5E7cUkG4A5VtSnDVWncCnqe5y5pz7zNFTIxoVGwFaZe6tqWJ7wEDZv7HZGJBX1GwRs3uauIzif5Hc1Rk3gp8zBo0CDNzY2/5XaDtvoteGYMXPak++U0dXdwDzx+vpsZO/l16JDtd0Qmlsz4JSx9EW5cDalR0W0bkIjMV9WAReCCmSjXXUReFJEVIrKu9Bb6ME2ddPOqzVkzU2gUF7n1lbYshTGPW3IwtZc1EQr3uVVeY1Qwo5geAx4EioBhwJNA/MwljxdJyW4tmDVzXLU5c/RU4fVfwZq34YK/utmxxtRW5iBo1Sum50QEkyAaqOocXHPUN6o6BbggvGGZo5J1BaCwcKrfkcS2D+51V2Kn3giDfuh3NCZWlS7glzcPvvvS72iOSjAJ4qCIJAFficg1InIxYEtWRqNmXeCYM9xiYVZt7ugsnArv3e1Ghv3gVr+jMbGu/1g3wjBGryKCXYupIXAtcDwwAbDF86JV9kTYtQG+ft/vSGLPmjmunvQxZ7h60jE8ft1EibIRhtOg6JDf0dRatQnCW3DvclXdo6p5qvpDVb1UVWN7cG886zUCGjSzzura2rwEnp/k2owve9KGCpvQyZoI+76H1W/6HUmtVTdRrp6qFgOnRDAeU1f1Ut1l7crXYO82v6OJDTu/halj3OKHV7wAaU38jsjEk9IRhjHYzFTdFcQX3s+F3uzpHBG5pPQWieDMUcrOgZJCqzYXjP07YOpoKNwPV7wIGe39jsjEm6Rkt4Dfmndg9ya/o6mVYPog0oBtwA+AEcCF3k8Trdr0hQ7HW7W5mhQdhGkTYNtaGPs0tKlcrsSYEMmaAFoCi56pedsoUl2CaO0t670MWOr9XO79XBaB2ExdZE+E/JWQl8Czy6tTUgLTr4JvPoKLHoSup/kdkYlnzY+BLqfG3AjD6hJEMm44a2Pc8t6NK91MNOt7ias2t9A6qwOaM8UVWjprCvQf43MwJiFk5cCOr+Gbj/2OJGjVLda3WVXviFgkJrTSMlySWPYynPu/kGo5vcwX/4aP/w8G/RiGXu93NCZR9BkJs37jOqu7nup3NEGp7grCBoHHuuyJrtrc8lf8jiR6rHzNfUh7ng/n32tzHUzk1G8A/S6FFa/C/p1+RxOU6hLEmRGLwoRHxyHQsofNiSj17Tx46cdu4b1LH7WiPybysnKg6IBr3owBVSYIq78QB0qrzeV9EbNrwYTMtrXw7OWQ3g7GPQcpDf2OyCSi9lnQ5riYmRMRzDBXE8v6j4Wk+jHzCxkWe/Lh6Uvd/QkvueUPjPGDiLuK2LQQtkT/YFBLEPGufLW5ooN+RxN5h/a5K4eCLe7KocWxfkdkEl3/yyA5JSa+tFmCSATZk2DfNlg1y+9IIquk2PU5bFoIox+FjoP9jsgYV7a21wVupYMo/9JmCSIRHDsMMjJhQfR/YwkZVTdaadUsOO/P7gNpTLTIynHLvHz5ut+RVMsSRCJISnbFhNa+Czs3+B1NZHx8P+Q+CkOvgyE/9TsaYyo6Zhg06Rj1zUyWIBLFwCvcz0SoNrfkBXhnChx3KZw5xe9ojDlSUpL7TK59L6q/tFmCSBTNOrtCOIumurb5ePX1B26Npc6nuDWWkuxX3ESpgePdzyhewM8+PYkkeyLs+hbWved3JOGxdQVMuwJadIOxU11tDGOiVbPOcMzp7qo+ShfwswSRSHpdAA2ax2dn9e5Nrq5DSiNX9KdBU78jMqZmWTleieC5fkcSkCWIRFIvFQaMdSMn9n7vdzShc2C3qwh3YDeMfx6advQ7ImOC02sEpDWN2s5qSxCJJsurNrd4mt+RhEbRIXg+B/K/hMufhHb9/Y7ImODVT3MT51a+Bvuib3UjSxCJpk0fyBzsvrHEerU5VZh5Lax7H0b+A479gd8RGVN7WTlQfBCWvuh3JEewBJGIsrxv3Hnz/I6kbt672y0hMux3h0eEGBNr2vWHdgOisriXJYhEdNwlUL8RLHjC70iOXu5j8MG9bmTWab/xOxpj6iYrB7YshU2L/I6kAksQiSg1HY67GJa9AgcL/I6m9lbPhtdvgG5nwwV/s6I/Jvb1GwP10qKus9oSRKLKngSFe11J0liycQG8MBna9oMxj0NydVVzjYkRDZpC7wvdKgCF+/2OpowliESVORha9Yq6byzV2v41PHMZNGoJ41+wOtsmvmTlwMFdbkRTlLAEkahKC5fkzXMzkKPdvu1uIlxxIVzxEqS38TsiY0Kry6nQtHNUdVZbgkhkA2Kk2lzhfnh2LOz8FsZNg1Y9/I7ImNBLSnJf2r7+wF0tR4GwJggRGS4iq0RkjYjcHOD1VBF5znv9cxHp4j3fRUT2i8gi7/ZQOONMWI1auuU3Fk+L3sIlJcXw8k/h2y/gkkeg80l+R2RM+AwcD4hbVDMKhC1BiEgy8ABwHtAHGCcifSpt9mNgh6p2A/4G/Knca2tVdaB3uzJccSa87BzYvz16C5fM/h2snAnn/hH6XuR3NMaEV5MO0O1Mt8JrFKy6HM4riCHAGlVdp6qHgGnAqErbjAJKB+O/CJwpYmMWI6q0cMmC6Gn3LPPpA/D5g3Di1XDS1X5HY0xkZOXA7o2uVoTPwpkgOgDflnuc5z0XcBtVLQJ2AS2817qKyEIRmSsipwY6gYj8TERyRSQ3Pz8/tNEniqRkV7hk3fuw4xu/ozls2csw+xboMwrOudvvaIyJnJ7nQ8MWUdFZHa2d1JuBTqqaBdwAPCMiGZU3UtVHVHWQqg5q1apVxIOMG1letbkoaffkm0/glZ9DxxPh4kes6I9JLPVSoP9Y+HKW76suh3OW0Uag/LrLmd5zgbbJE5F6QBNgm6oqcBBAVeeLyFqgB5AbxngTV9NObqG7hU/D6f/jrir8kr8Knh3nhvuNe9atdlmFwsJC8vLyOHDgQAQDjG9paWlkZmZSv359v0NJbFkT4LMHYMlzcNIvfAsjnAliHtBdRLriEsFYoPKKajOAScCnwGjgXVVVEWkFbFfVYhE5BugOrAtjrCY7x81QXvsedD/LnxgKtsDToyE5BSa8CA2bV7t5Xl4e6enpdOnSBeu6qjtVZdu2beTl5dG1a1e/w0lsbfpAh+Ndca8Tr/ZtOZmwXbt7fQrXALOBlcDzqrpcRO4QkZHeZo8CLURkDa4pqXQo7GnAEhFZhOu8vlJVo2+x9HhS2u7p1wJ+BwvcLOl92+CK56FZlxp3OXDgAC1atLDkECIiQosWLeyKLFpk5UD+Sre8jE/CupCNqs4CZlV67g/l7h8AxgTY7yXgpXDGZiqplwoDxsHnD8OefGgcwT6d4kJ39bJlmZsI1z4r6F0tOYSWvZ9R5LhL3UCNhU9C5vG+hGC9f+aw0mpzSyJYbU4VXvsVrHkHRvwNepwTuXMbE83SMqDPRbD0JTi015cQLEGYw1r3gswhbk5EpKrNzf2zW+rjtJvg+EmROWeIbNu2jYEDBzJw4EDatm1Lhw4dyh4fOnSo2n1zc3O59tprIxSpiVlZE+BQAayY4cvpba1kU1H2RJhxjVvaotMJ4T3Xwqnw/h9hwHgYdkt4zxUGLVq0YNEiV+BlypQpNG7cmBtvvLHs9aKiIurVC/wRGzRoEIMGDYpInCaGdT4Zmh/rvkQNHBfx01uCMBX1vRjevNldRYQzQax5x9WTPmYYXPh/dR6lcfvM5azYtDtEwTl92mdw24V9a7XP5MmTSUtLY+HChQwdOpSxY8dy3XXXceDAARo0aMBjjz1Gz549ef/997nvvvt47bXXmDJlChs2bGDdunVs2LCB66+/3q4ujCPiriLm3A7b1kKLYyN6emtiMhWlNnYlSZe/DAdC+we3zObF8PwkaNUbLnvSTQyKI3l5eXzyySf89a9/pVevXnz44YcsXLiQO+64g1tuCXyl9OWXXzJ79my++OILbr/9dgoLCyMctYlaA8eDJPuy6rJdQZgjZU10VxDLX4bjJ4f22Ds3wNTLIK2pG86adsQE+aNS22/64TRmzBiSk91kw127djFp0iS++uorRKTKP/wXXHABqamppKam0rp1a7Zu3UpmZmYkwzbRKr0tdD8bFj0Lw26NaBVFu4IwR8oc5L7dh3oBv/073ES4wv1uIlxG+9AeP0o0atSo7P7vf/97hg0bxrJly5g5c2aVcwxSU1PL7icnJ1NUVBT2OE0MycqBPVtc02wEWYIwRxJxndUb58PW5aE5ZtFBmHYF7Pgaxk6F1r1Dc9wot2vXLjp0cGtUPv744/4GY2JXj3OhUeuINzNZgjCB9b/cVZtbEIJfyJISeOVK+OZjuOhB6Bpwcd64dNNNN/Hb3/6WrKwsuyowRy+5vqsAufpN2PNdxE4rGqnx7mE2aNAgzc21tfxC6oXJbhnwX69yM62P1lu/h0/+DmfdDqdcH6roWLlyJb17J8aVSCTZ+xql8lfDA4Ph7Dtg6HUhO6yIzFfVgGOu7QrCVC17ous3+PK1oz/G54+45DD4pyH9pTYm4bTqAR1PcKsuR+iLvSUIU7WuZ0CTTkffWb1yJrxxE/S8AM77k28rUhoTN7Jy4PvVbiJrBFiCMFVLSnKTdNa9DzvW127fb7+Al37iliy+9D/+1pgwJl70vRhSGkes2pwlCFO9geMBcctiBOv7NfDM5W4Y6/jnIKVh2MIzJqGkNnZJYtkrbon8MLMEYarXtCN0O9O1e5YU17z9nnyYeqlrTrriRWjUMvwxGpNIsidC4V5Y/krYT2UJwtQseyIUbII1c6rf7tBeV/SnYCuMfz7i68YYkxAyB0PLHu5LW5hZgjA163EeNGxZfbtncRG8+CPYvAhG/9fNxo5zw4YNY/bs2RWeu//++7nqqqsCbn/GGWdQOhT7/PPPZ+fOnUdsM2XKFO67775qzzt9+nRWrFhR9vgPf/gD77wT2Rm2xkcirrP6289dDfcwsgRhalYvxU3SWfVG4Ek6qvDGb9wknvPvhV7nRz5GH4wbN45p0yoWV5o2bRrjxtW8LPOsWbNo2rTpUZ23coK44447OOssn+qIG38MGAdJ9cI+s9oW6zPByZ4In/4TFj975HyGj/4Guf+FodfD4J/4E98bN8OWpaE9Ztt+cN49Vb48evRobr31Vg4dOkRKSgrr169n06ZNPPvss9xwww3s37+f0aNHc/vttx+xb5cuXcjNzaVly5bcfffdPPHEE7Ru3ZqOHTty/PGuvOS///1vHnnkEQ4dOkS3bt146qmnWLRoETNmzGDu3LncddddvPTSS9x5552MGDGC0aNHM2fOHG688UaKiooYPHgwDz74IKmpqXTp0oVJkyYxc+ZMCgsLeeGFF+jVq1do3y8TOY1bQY/hsHganHmbm2kdBnYFYYLTqqebpLPgqYqTdJY879aq7zfG/aImkObNmzNkyBDeeOMNwF09XHbZZdx9993k5uayZMkS5s6dy5IlS6o8xvz585k2bRqLFi1i1qxZzJs3r+y1Sy65hHnz5rF48WJ69+7No48+ysknn8zIkSO59957WbRoEccee7if58CBA0yePJnnnnuOpUuXUlRUxIMPPlj2esuWLVmwYAFXXXVVjc1YJgZk5cDefFg9u+Ztj5JdQZjgZU+EV38BGz6DzifBurkw/WrociqMesDNm/BLNd/0w6m0mWnUqFFMmzaNRx99lOeff55HHnmEoqIiNm/ezIoVK+jfv3/A/T/88EMuvvhiGjZ0Q4FHjhxZ9tqyZcu49dZb2blzJ3v27OHcc8+tNpZVq1bRtWtXevToAcCkSZN44IEHuP56t7zJJZdcAsDxxx/Pyy+/XOd/u/FZt7OgcVvXzNR7RFhOYVcQJnh9LoKUdPcLuXU5PDcBWnSDy5+u21pNMWzUqFHMmTOHBQsWsG/fPpo3b859993HnDlzWLJkCRdccEGVS3zXZPLkyfzzn/9k6dKl3HbbbUd9nFKlS4rbcuJxIrmem6f01Vuwe3NYTmEJwgSvtNrcspddXYeURq6uQ4Oj62yNB40bN2bYsGH86Ec/Yty4cezevZtGjRrRpEkTtm7dWtb8VJXTTjuN6dOns3//fgoKCpg5c2bZawUFBbRr147CwkKmTj08UTE9PZ2CgiMnSfXs2ZP169ezZs0aAJ566ilOP/30EP1LTVTKmgBaAoufCcvhLUGY2smeBEX73SzOK16EJlb1bNy4cSxevJhx48YxYMAAsrKy6NWrF+PHj2fo0KHV7pudnc3ll1/OgAEDOO+88xg8eHDZa3feeScnnHACQ4cOrdChPHbsWO69916ysrJYu3Zt2fNpaWk89thjjBkzhn79+pGUlMSVV14Z+n+wiR4tjoXOp7i+wDCw5b5N7ai6UUudh0KnE3wNxZalDg97X2PMd1+6FQuOctWC6pb7tk5qUzsicOoNfkdhjCnVOnzDla2JyRhjTECWIExMi5cm0mhh76cpzxKEiVlpaWls27bN/qiFiKqybds20tLS/A7FRAnrgzAxKzMzk7y8PPLz8/0OJW6kpaWRmWkj04xjCcLErPr169O1a1e/wzAmblkTkzHGmIAsQRhjjAnIEoQxxpiA4mYmtYjkA9/U4RAtge9DFE4oWVy1Y3HVjsVVO/EYV2dVbRXohbhJEHUlIrlVTTf3k8VVOxZX7VhctZNocVkTkzHGmIAsQRhjjAnIEsRhj/gdQBUsrtqxuGrH4qqdhIrL+iCMMcYEZFcQxhhjArIEYYwxJqCEShAiMlxEVonIGhG5OcDrqSLynPf65yLSJUrimiwi+SKyyLv9JEJx/VdEvhORZVW8LiLydy/uJSKSHSVxnSEiu8q9X3+IUFwdReQ9EVkhIstF5LoA20T8PQsyroi/ZyKSJiJfiMhiL67bA2wT8c9kkHH58pn0zp0sIgtF5LUAr4X2/VLVhLgBycBa4BggBVgM9Km0zdXAQ979scBzURLXZOCfPrxnpwHZwLIqXj8feAMQ4ETg8yiJ6wzgNR/er3ZAtnc/HVgd4P8y4u9ZkHFF/D3z3oPG3v36wOfAiZW28eMzGUxcvnwmvXPfADwT6P8r1O9XIl1BDAHWqOo6VT0ETANGVdpmFPCEd/9F4EwRkSiIyxeq+gGwvZpNRgFPqvMZ0FRE2kVBXL5Q1c2qusC7XwCsBDpU2izi71mQcUWc9x7s8R7W926VR81E/DMZZFy+EJFM4ALgP1VsEtL3K5ESRAfg23KP8zjyQ1K2jaoWAbuAFlEQF8ClXpPEiyLSMcwxBSvY2P1wktdE8IaI9I30yb1L+yzct8/yfH3PqokLfHjPvOaSRcB3wNuqWuX7FcHPZDBxgT+fyfuBm4CSKl4P6fuVSAkils0Euqhqf+BtDn9DMIEtwK0vMwD4BzA9kicXkcbAS8D1qro7kueuTg1x+fKeqWqxqg4EMoEhInJcJM5bkyDiivhnUkRGAN+p6vxwn6tUIiWIjUD5LJ/pPRdwGxGpBzQBtvkdl6puU9WD3sP/AMeHOaZgBfOeRpyq7i5tIlDVWUB9EWkZiXOLSH3cH+GpqvpygE18ec9qisvP98w7507gPWB4pZf8+EzWGJdPn8mhwEgRWY9riv6BiDxdaZuQvl+JlCDmAd1FpKuIpOA6cGZU2mYGMMm7Pxp4V73eHj/jqtRGPRLXhhwNZgATvZE5JwK7VHWz30GJSNvSdlcRGYL7PQ/7HxXvnI8CK1X1r1VsFvH3LJi4/HjPRKSViDT17jcAzga+rLRZxD+TwcTlx2dSVX+rqpmq2gX3d+JdVZ1QabOQvl8JU3JUVYtE5BpgNm7k0H9VdbmI3AHkquoM3IfoKRFZg+sEHRslcV0rIiOBIi+uyeGOC0BEnsWNbmkpInnAbbgOO1T1IWAWblTOGmAf8MMoiWs0cJWIFAH7gbERSPTgvuHlAEu99muAW4BO5WLz4z0LJi4/3rN2wBMikoxLSM+r6mt+fyaDjMuXz2Qg4Xy/bKkNY4wxASVSE5MxxphasARhjDEmIEsQxhhjArIEYYwxJiBLEMYYYwKyBGGMR0T2eD+7iMj4EB/7lkqPPwnl8Y0JB0sQxhypC1CrBOHNWq1OhQShqifXMiZjIs4ShDFHugc41Vvn/1fewm33isg8b3G2n0NZDYUPRWQGsMJ7brqIzBdXR+Bn3nP3AA284031niu9WhHv2MtEZKmIXF7u2O97C8F9KSJTy810vkdcbYclInJfxN8dkzASZia1MbVwM3Cjqo4A8P7Q71LVwSKSCnwsIm9522YDx6nq197jH6nqdm+Jhnki8pKq3iwi13iLv1V2CTAQGAC09Pb5wHstC+gLbAI+BoaKyErgYqCXqmrpkhDGhINdQRhTs3Nw6yctwi2T3QLo7r32RbnkAG4JhsXAZ7hF07pTvVOAZ73VQ7cCc4HB5Y6dp6olwCJc09cu4ADwqIhcgluuw5iwsARhTM0E+KWqDvRuXVW19Apib9lGImcAZwEnectmLwTS6nDeg+XuFwP1vDX+h+CKwYwA3qzD8Y2pliUIY45UgCvNWWo2biG7+gAi0kNEGgXYrwmwQ1X3iUgvXEnRUoWl+1fyIXC518/RCldO9YuqAhNX06GJtyT3r3BNU8aEhfVBGHOkJUCx11T0OPB/uOadBV5HcT5wUYD93gSu9PoJVuGamUo9AiwRkQWqekW5518BTsLVIlfgJlXd4iWYQNKBV0UkDXdlc8PR/RONqZmt5mqMMSYga2IyxhgTkCUIY4wxAVmCMMYYE5AlCGOMMQFZgjDGGBOQJQhjjDEBWYIwxhgT0P8D5LYzEU0Cu9oAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 0.14545520677990761\n",
            "Final Validation Accuracy: 0.015881861242685986\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#train\n",
        "model3 = CNN()\n",
        "use_cuda = True\n",
        "model3.cuda()\n",
        "\n",
        "train(model3, train_data, val_data, lr=0.1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "WqcnI8fyD-mW",
        "outputId": "6ffcb491-708a-478f-cc52-d3f25819af19"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  0  Validation Accuracy:  0.1465589300640847\n",
            "Epoch 1\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  1  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 2\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  2  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 3\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  3  Validation Accuracy:  0.1368069100027863\n",
            "Epoch 4\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "Epoch:  4  Validation Accuracy:  0.1744218445249373\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 0.149128869166697\n",
            "Final Validation Accuracy: 0.1744218445249373\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Convolutional Neural Network Architecture\n",
        "class CNN2(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNN2, self).__init__()\n",
        "\n",
        "        self.pool = nn.MaxPool2d(2, 2) #kernel_size, stride \n",
        "\n",
        "        self.conv1 = nn.Conv2d(3, 5, 3, padding = 2) #in_channels, out_chanels, kernel_size\n",
        "        self.conv2 = nn.Conv2d(5, 50, 3) #in_channels, out_chanels, kernel_size\n",
        "        self.conv3 = nn.Conv2d(50, 100, 3)\n",
        "        \n",
        "        self.fc1 = nn.Linear(100*4*4, 32) #chanels*dimension\n",
        "        self.fc2 = nn.Linear(32, 7) #last output channel always = 7\n",
        "        self.dropout = nn.Dropout(0.4)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        # 25x25\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        # 11\n",
        "        x = self.pool(F.relu(self.conv3(x)))\n",
        "        # 4\n",
        "\n",
        "\n",
        "        x = x.view(-1, 100*4*4)\n",
        "        x = F.relu(self.dropout(self.fc1(x)))\n",
        "        # x = F.relu(self.dropout(self.fc2(x)))\n",
        "        x = self.fc2(x)\n",
        "        # x = x.squeeze(1)\n",
        "        return x"
      ],
      "metadata": {
        "id": "cj89zhaxIetU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#train\n",
        "model5 = CNN2()\n",
        "use_cuda = True\n",
        "model5.cuda()\n",
        "\n",
        "train(model5, train_data, val_data, batch_size = 3000,lr=0.05,num_epochs=20)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "F-QNk5e1H3ld",
        "outputId": "35e5ade7-6afc-4dda-de72-a22ef1ecc42d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  0  Validation Accuracy:  0.14739481749791028\n",
            "Epoch 1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  1  Validation Accuracy:  0.1368069100027863\n",
            "Epoch 2\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  2  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 3\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  3  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 4\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  4  Validation Accuracy:  0.14711618835330176\n",
            "Epoch 5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  5  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 6\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  6  Validation Accuracy:  0.015324602953468934\n",
            "Epoch 7\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  7  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  8  Validation Accuracy:  0.2449150181108944\n",
            "Epoch 9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  9  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 10\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  10  Validation Accuracy:  0.14711618835330176\n",
            "Epoch 11\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  11  Validation Accuracy:  0.2449150181108944\n",
            "Epoch 12\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  12  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 13\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  13  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 14\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  14  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 15\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  15  Validation Accuracy:  0.1368069100027863\n",
            "Epoch 16\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  16  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 17\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  17  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 18\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  18  Validation Accuracy:  0.2449150181108944\n",
            "Epoch 19\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  19  Validation Accuracy:  0.1744218445249373\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXicdbXA8e/J0qRbpvuWdAtSlrZ0IQUKpR0E2WQRRKG4tBcvCIqgXkFEhYroRUHlqqigIIooCEgtyCIgKTttgdKV0jZtadqme5N0SZrl3D9+76STdDKZJPO+M0nO53nyZJZ3OZnMvGd+u6gqxhhjTFMZqQ7AGGNMerIEYYwxJiZLEMYYY2KyBGGMMSYmSxDGGGNisgRhjDEmJksQpssTkWdFZFaytzWmoxMbB2E6IhHZG3W3B1AN1Hn3v6yqDwcfVfuISB5wG3Ax0A/YCjwF3K6qO1IZm+marARhOiRV7RX5AT4Czo96rCE5iEhW6qJMnIh0A14CxgJnA3nAVGAncEIbjtch/m6T3ixBmE5FRMIiUioi3xaRMuCPItJXRJ4Wke0istu7XRC1T7GI/Ld3e7aIvCYid3nbrhORc9q47WgReUVEKkXkRRG5R0T+0kzoXwRGABep6gpVrVfVbar6Q1V9xjueisjHoo7/oIjcHufvXiki50Vtn+W9BpO9+yeJyBsiskdE3heRcHtff9O5WIIwndEQXBXNSOAq3Pv8j979EcAB4Ndx9j8RWAUMAH4K3C8i0oZt/wosAPoDc4AvxDnnGcBzqro3zjYtafp3/w2YGfX8WcAOVX1XRPKBfwG3e/t8C3hCRAa24/ymk7EEYTqjeuBWVa1W1QOqulNVn1DV/apaCfwImBFn/w2q+ntVrQP+BAwFBrdmWxEZAUwBblHVg6r6GjAvzjn7A1ta92ceptHfjUtQF4hID+/5y3FJA+DzwDOq+oxXWnkBWASc284YTCdiCcJ0RttVtSpyR0R6iMi9IrJBRCqAV4A+IpLZzP5lkRuqut+72auV2w4DdkU9BrAxTsw7ccmlPRr93aq6BlgJnO8liQtwSQNcKeMzXvXSHhHZA0xLQgymE7GGLNMZNe2a9z/AUcCJqlomIhOB94Dmqo2SYQvQT0R6RCWJ4XG2fxG4XUR6quq+ZrbZj+uxFTEEKI26H6tLYqSaKQNY4SUNcMnqIVW9soW/w3RhVoIwXUFvXLvDHhHpB9zq9wlVdQOuymaOiHQTkanA+XF2eQh30X5CRI4WkQwR6S8iN4tIpNpnMXC5iGSKyNnEryaLeAQ4E7iGQ6UHgL/gShZnecfL9Rq6C2IexXRJliBMV3A30B3YAbwFPBfQeT/Hoa6qtwOP4sZrHEZVq3EN1R8ALwAVuAbuAcDb3mbX45LMHu/Yc1sKQFW3AG8CJ3vnjzy+EbgQuBnYjktON2DXBBPFBsoZExAReRT4QFV9L8EYkwz2bcEYn4jIFBE5wqsuOhv3jb3Fb/3GpAtrpDbGP0OAf+C6sJYC16jqe6kNyZjEWRWTMcaYmKyKyRhjTEydpoppwIABOmrUqFSHYYwxHco777yzQ1VjTrHSaRLEqFGjWLRoUarDMMaYDkVENjT3nFUxGWOMicnXBCEiZ4vIKhFZIyI3xXj+myKyQkSWiMhLIjIy6rk6EVns/cSb5MwYY4wPfKti8iZCuwf4BK6L30IRmaeqK6I2ew8oUtX9InINbrrkS73nDqjqRL/iM8YYE5+fbRAnAGtUtQRARB7BDRRqSBCq+nLU9m/hpiBOmpqaGkpLS6mqqmp5Y5OQ3NxcCgoKyM7OTnUoxhif+Zkg8mk8vXEpbnGV5nwJeDbqfq6ILAJqgTtU9bARqCJyFW5hFEaMGHHYAUtLS+nduzejRo2i+fVeTKJUlZ07d1JaWsro0aNTHY4xxmdp0UgtIp8HioA7ox4eqapFuEVO7haRI5rup6r3qWqRqhYNHHh4L62qqir69+9vySFJRIT+/ftbicyYLsLPBLGJxvPfF3iPNSIiZwDfBS7wZrQEQFU3eb9LgGJgUluCsOSQXPZ6GtN1+JkgFgJHegu3dwMuo8mSiyIyCbgXlxy2RT3eV0RyvNsDgFOIarswJqlWPQs716Y6irZb+x/Y9kGqozBtVboIPnq75e1SwLcEoaq1wLXA87hlD/+uqstF5DYRucDb7E7c8oyPNenOegywSETeB17GtUF0uASxc+dOJk6cyMSJExkyZAj5+fkN9w8ePBh330WLFnHdddcFFGkXVr0XHv0CvPSDVEfSNqrw2Gx47rBe5Kaj+OdX4ckvpzqKmHwdSa2qzwDPNHnslqjbZzSz3xvAeD9jC0L//v1ZvHgxAHPmzKFXr15861vfani+traWrKzY/4KioiKKiooCibNL2/AG1NfAulehvh4y0qJZLnF7NkBVOXz0FtRWQ1ZOqiMyrVGxBbZ7pb89H0GfwzvbpFIH+zR0fLNnz+bqq6/mxBNP5MYbb2TBggVMnTqVSZMmcfLJJ7Nq1SoAiouLOe+88wCXXK644grC4TCFhYX88pe/TOWf0Lmsm+9+H9gFW5emNpa22LLE/a49ABsXpDYW03rrXjl0u2R+6uJoRqeZi6klP3hqOSs2VyT1mMcOy+PW88e2er/S0lLeeOMNMjMzqaio4NVXXyUrK4sXX3yRm2++mSeeeOKwfT744ANefvllKisrOeqoo7jmmmtsLEIylBTDwGNg+0p3e+iEVEfUOmVLQTIAcfGPPjXVEZnWKCmG7v0gI8vdnvyFVEfUSJdJEOnkM5/5DJmZmQCUl5cza9YsVq9ejYhQU1MTc59PfvKT5OTkkJOTw6BBg9i6dSsFBba+fLvs3Q5bl8Hpt8D7j7pvcKdcn+qoWqdsCQwYAzm9vdLQ91MdkUmUqvufjZ4OmdkuQahCGvUU7DIJoi3f9P3Ss2fPhtvf//73Oe2003jyySdZv3494XA45j45OYfqljMzM6mtrfU7zM4vUr1UGIbKrfDunztePf6WJTBqmqu7fu3nrj0iN5TqqEwidq6Bik1QeINLEEsfg20rYHD6XKusDSLFysvLyc/PB+DBBx9MbTBdzbr57mI6dCIUznD1+KULUx1V4vbtgMrNMPQ4l+S0Hta/nuqoTKJKit3vwhkweob3WHq1Q1iCSLEbb7yR73znO0yaNMlKBUFShbXFMOpUyMh038Il49CHtiMo8xqoh4yH4SdAVveOFX9XV1LsSn59R0Of4dDviLT7/3WZKqZUmzNnTszHp06dyocffthw//bbbwcgHA43VDc13XfZsmV+hNi17F4H5R/BKd5Yk9wQ5B/vPqAf/15KQ0tYpAfTkONctdjIqWl3gTHNqK+D9a/CMRccanMoDMOSR6GuxlU5pQErQZiuqSSq/SFi9AzY9K6rx+8IypZAaDj06OfuF4ZhxyrXt96kty2L3fusMHzoscIZcHAvbHonVVEdxhKE6ZpKiiEvH/p/7NBjhWHQuo5Tj1+21JUeIiL12OvSqx7bxBAp6UX+Z+CqOyPdldOEJQjT9dTXuwFKo2c07lIYqcfvCBfYg/tgx2rX/hAx5Djo3jftGjpNDCXzYfA46BU1C3WPfm4cThr9/yxBmK5n61I3crow3PjxjlSPv3U5oK4HU0RGhutTH+lPb9JTzQE3NUph+PDnCsNQusDNEZYGLEGYrifyDW309MOfGz3DzY1TWRZsTK1VFtVAHa0w7Lq+7lwTdEQmUR+9BXXVjauXIgrDUF8LH70ZdFQxWYIwXU9JMQw8GvKGHv5cYdjbJn2K+TFtWQK5fSDUZDR9Ydj97giloK5q3Xw3tcbIkw9/bsRJkJmTNv8/SxA+O+2003j++ecbPXb33XdzzTXXxNw+HA6zaNEiAM4991z27Nlz2DZz5szhrrvuinveuXPnsmLFoRnSb7nlFl588cXWht/51Fa7GVwLw7Gfj9Tjp3s7RNkSV73UdFqGvqMhNCJtLjAmhpJiKJgCOb0Ofy67O4w4MW3+f5YgfDZz5kweeeSRRo898sgjzJw5s8V9n3nmGfr06dOm8zZNELfddhtnnBFzdvWupXShGzEdq3gPHaMev64Wtq44vHoJXMIonOFNX14XfGwmvgO7YfPi5r+ggHtvbl3m5gpLMUsQPrvkkkv417/+1bBA0Pr169m8eTN/+9vfKCoqYuzYsdx6660x9x01ahQ7duwA4Ec/+hFjxoxh2rRpDVOCA/z+979nypQpTJgwgU9/+tPs37+fN954g3nz5nHDDTcwceJE1q5dy+zZs3n88ccBeOmll5g0aRLjx4/niiuuoLq6uuF8t956K5MnT2b8+PF88EEnXKWspBgkE0ad0vw2hWE3R0661uPv+NDVYcdKEODiry53FyKTXta9Cmj8BFF4mrdt6kuxXWck9bM3uX7jyTRkPJxzR9xN+vXrxwknnMCzzz7LhRdeyCOPPMJnP/tZbr75Zvr160ddXR2nn346S5Ys4bjjYn/g33nnHR555BEWL15MbW0tkydP5vjjjwfg4osv5sorrwTge9/7Hvfffz9f+9rXuOCCCzjvvPO45JJLGh2rqqqK2bNn89JLLzFmzBi++MUv8tvf/pavf/3rAAwYMIB3332X3/zmN9x111384Q9/aO+rlF5K5kP+5PgT2jXMi1MMA44MJKxWiTRQD20mQUQa39cVQ8HxgYRkErRuPnTr5UbtN2fYRMgJuW3HX9L8dgGwEkQAoquZItVLf//735k8eTKTJk1i+fLljaqDmnr11Ve56KKL6NGjB3l5eVxwwQUNzy1btoxTTz2V8ePH8/DDD7N8+fK4saxatYrRo0czZswYAGbNmsUrrxxatOTiiy8G4Pjjj2f9+vVt/ZPTU1WFG6VaGI6/Xb/C9K7HL1sKWbnQv5nk1WsQDBqbvvF3ZSXFMPKU+FNpZGS6dT3S4P/XdUoQLXzT99OFF17IN77xDd599132799Pv379uOuuu1i4cCF9+/Zl9uzZVFVVtenYs2fPZu7cuUyYMIEHH3yQ4uLidsUamVa8U04pvuF1N1K6ufaHiEg9/sp5rh4/IzOY+BK15X0YdCxkxvn4FoZh4R9cn/vs7kFFZuIpL3XVlkVXtLxtYRg+eBp2rYN+o/2OrFlWgghAr169OO2007jiiiuYOXMmFRUV9OzZk1AoxNatW3n22Wfj7j99+nTmzp3LgQMHqKys5Kmnnmp4rrKykqFDh1JTU8PDDz/c8Hjv3r2prKw87FhHHXUU69evZ80aV7/+0EMPMWNGCxfMzqKk2I2UHn5Cy9sWht1cOVvSrB5f9VAPpngKw66d4qO3gojKJCLW/F/Nia7mTCFLEAGZOXMm77//PjNnzmTChAlMmjSJo48+mssvv5xTTonTYApMnjyZSy+9lAkTJnDOOecwZcqUhud++MMfcuKJJ3LKKadw9NFHNzx+2WWXceeddzJp0iTWrl3b8Hhubi5//OMf+cxnPsP48ePJyMjg6quvTv4fnI5Kil3f80QWBIrU46fbeIg9H7nE1VwDdcTIk11f+zRo6DSekmLoOdCV/loy4EjoPSzlCUI0XbvytVJRUZFGxg9ErFy5kmOOOSZFEXVeHfJ1rSyDnx0Fn7gt8WVFf3My9BwAs+b5G1trrHwaHv0c/PdLUFAUf9sHzobaKriqOIjITDyq7v036lS45P7E9nnyavjwebhhret+7RMReUdVY76ZrARhuobWFO8jCsOuiqbmQPLjaauyJW5ho0S+hY6e4bq67t/lf1wmvu0fwN6trm0rUYVhN2fY1iT3vmwFSxCma1g3H7r3g8HjW942onCGq8ff+LZ/cbXWliWu91K3Hi1vWxgGFNa/5nNQpkUNy4uGE98nDZYh7fQJorNUoaWLDvl6qroP6OjprSuqR+rx06C7YYOypS03UEfkHw/ZPdMr/q6qZL7rPt1nROL75A2FAUel9P/XqRNEbm4uO3fu7JgXtTSkquzcuZPc3NxUh9I6O9e6kdGtKd4D5PR2c+akS0P1/l1QUdp4DYh4srq5EePWUJ1adbWuFNdS9+pYCsNuZtfa6mRHlZBOPQ6ioKCA0tJStm9P/ZwmnUVubi4FBQUtb5hOSl52vwvDrd939AyY/xM3h073vsmMqvW2vO9+t9SDKVphGFb/2/XBbzrzqwnG5nfhYGXb3n+FM2DBvW4OsVHTkh1Zizp1gsjOzmb06NQNMjFpoqTYFe37tuG9UBiG+Xe4b4DHnJ/kwFopMlVMaxJEdD32pM8lPybTspJiQGKvP9KSUdNcp4SS4pQkiE5dxWQM9XWw/tXDlxdNVDrV45ctceto9+yf+D6DjnV979Mh/q6qZL5rN+rRr/X75oZg2OSUVXNagjCd25bFbmBZYbht+0fq8dOhHWLLktaVHuDQ9OXr5qfv9OWd2cF9rhdcW9ofIgrDbg6xqopkRZUwSxCmc2tYXrSdH9Cdq6F8UzIiapuD+10MifZgilYYdn3wt3fC6dvT3YY3ob6m7V9QwO2rdW4usYBZgjCdW0kxDB4HvQa2/RiR5JLK3kDbVoDWt74EAWkzr0+XtK4YMrvBiKltP8bwE9wcYin4/1mCMJ1XzQE3Ero9pQdIj3r8hh5MrRjoF9F3pGugT4dqsq6mpBiGn5jYwMbmZOXAyKkp+f9ZgjCd18a33UjownD7jpMOy5CWLYHcPq0baBWtMOx6YtV1sinc09m+na7nWWvH38QyegZsX+nmFAuQrwlCRM4WkVUiskZEborx/DdFZIWILBGRl0RkZNRzs0Rktfczy884TSdVMt+NhB55cvuPVRj26vFXtbSlP8qWutJDW3pigbtIHax0ffJNMCJVkqPD7T9WoXeMgEsRviUIEckE7gHOAY4FZopI0xnG3gOKVPU44HHgp96+/YBbgROBE4BbRSTFo5RMh1NS7EZC5/Rq/7FSWY9fVwtbl7et/SFi1HRArB0iSCXFkJMHwya1/1hDjnMDNQNuB/OzBHECsEZVS1T1IPAIcGH0Bqr6sqru9+6+BUSGep4FvKCqu1R1N/ACcLaPsZrO5sBu2Pxe+6uXIiL1+KloqN652k3b3ZYeTBE9+7sSiLVDBGfdfDe4Ld7Kf4lKUTWnnwkiH9gYdb/Ue6w5XwIiS6sltK+IXCUii0RkkU2nYRpZ/xqg7W+gjlYYTk09fltGUMdSGHbtMgf3tTci05Ld691PYTh5xywMuznFdq5tacukSYtGahH5PFAE3Nma/VT1PlUtUtWigQPb0Y3RdD4lxdCtV8uL6rRG4QyornAlkyBteR8yc9wqY+1ROMP1yd/wZnLiMs1ry/ojLWmo5nw5ecdsgZ8JYhMwPOp+gfdYIyJyBvBd4AJVrW7NvsY0q2S+a5zOzE7eMVNVj1+2BAYf2/6/ZcRU1yd/XXFSwjJxlBRDryEwYEzyjtmvEEIjAq3m9DNBLASOFJHRItINuAxotHajiEwC7sUlh21RTz0PnCkifb3G6TO9x4xpWfkmV29fGE7ucSP1+EG2Q6h6PZjaWb0E0K2n65NvDdX+qq+Hda+4919be53FIgKF092x6+uSd9w4fEsQqloLXIu7sK8E/q6qy0XkNhG5wNvsTqAX8JiILBaRed6+u4Af4pLMQuA27zFjWrbOh+J9RGE42Hr88lLX4N6WAXKxjJ7hEs6+nck5njnctuWwf0dyxj80VXiam1tsy+LkHzsGX9sgVPUZVR2jqkeo6o+8x25R1UgiOENVB6vqRO/ngqh9H1DVj3k/f/QzTtPJlBS7kc+JrNvcWoUzoO6gW8QlCGVL3O+hE5JzvMKw+22LCPknUkJLZgeJiMiU4QH1RkuLRmpjkqZhedE2Tu/dkkg9flDdRbcsAQQGj03O8YZNcn3zLUH4p2S+Wzc8FK/TZhv1GgSDxgZWTWgJwnQu21e5Ec9+FO8h+Hr8sqWu91K3nsk5XmaW65tv7RD+qD3oZl0tDPt3jsKwm2Os5oB/5/BYgjCdS+TCVxj27xxB1uOXLUle+0PE6BmH+umb5Nq0CGr2+/cFBbxqzmrXFuYzSxCmc1k33414buukdokoDAMK61/x7xwA+3dB+cbk9GCKVhh2v21UdfKVFLslQv1cHnTkyW6OsQD+f5YgTOdRV+tGOheG/T1PpB7f7w9oZAR1e6bYiGXgUa6PvlUzJV/JfPf+6O7j1HE5vd0cYwH8/yxBmM5j83tupHNh2N/zBFWPH+nBlOwShIirplj3iuuzb5KjqgJKF/rTe6mp0TPc+/3Abl9PYwnCdB4lxYAc6grop8Iw7F4Huzf4d44tS6D3MOg5IPnHLgy7vvrblif/2F3Vhjfc0qCFYf/PVRjGVXO+5utpLEGYzqOk2FXH9Ojn/7mCWIa0bGnyq5ciGub1sXaIpFk3H7JyXS83v+UfD9k9fS/FWoIwncPBfVC6IJjiPfhfj19zAHZ8mPweTBGhfNdX39ohkqekGEacBNm5/p8rqxuMOsX3BG8JwnQOH73pRjgXhoM5X6Qev2S+P/X4W1e46opktz9EK5zhqkVqD/p3jq6icitsWxHcFxRw59q52s095hNLEKZzKJnvRjiPmBrcOQvDXj3+iuQfu+x999uvKiZw8dfsc333Tfus87o8F4aDO2fkXD5Wc7aYIESkv29nNyZZSopd3W+3HsGd0892iLKlkBOCPiNb3ratRk1zffatmqn9Sooht0/y5sxKxKBj3ZxjPv7/EilBvCUij4nIuSJ+TG5jTDvt2+kuqH6OXo3Fz3r8Ld4Iaj8/ct37wtCJ1lDdXg3zf50KGZnBnTeAZUgTSRBjgPuALwCrReTHIpLEVTCMaaf1r+CWFw0Hf+7CMKx/HepqknfM+jrYutzf6qWIwrCrYqqu9P9cndWuEqgoDbZ6KaIw7OYe277Kl8O3mCDUeUFVZwJXArOABSIyX0QCrPA1phklxW5k87BJwZ+7cIarxy9NYj3+zjVQe8DfBuqIwhlQX+saq03bNEzvHQ7+3A3dlYt9OXxWSxt4bRCfx5UgtgJfw60MNxF4DBjtS2RdRW01PPoFqNjc9mNkZsFp34Mjz0heXImqrYa518Ckz8MRHw/+/OAaCEdNc69D0CL1+B8+ByOT9H1pS2QEtU9dXKMNP8n13Z93navPTpWJM2HqV1Nz7v/cDquea/v+lZshrwD6H5G8mBLVd6Sbe2zdfDjp6qQfPpFP1JvAQ8CnVLU06vFFIvK7pEfU1bz3EKx+Ho443X1Q22LrMvjHlfCVt6D34OTG15Li/4VlT7j67FQkiNpqV8Q/7rLgzw3u7z76PHjrtzBhJgw6uv3HLHsfMnPcWAu/ZefC6be4arJU2bUWXvohjP+MW+8gSNs/hFfucsk4NLxtx+gzAo4539/2ongmzHSlWB8kkiCOUo3dAqKqP0lyPF1LbTW8+gvX++bzT7T9Dbb9Q7j3VHjqOpj5SHBv1I/ehtf/z90uL42/rV8qvD7gfdr44U6GT/7MrQEw92r40guQmd2+45UthUHHtP84iZr61dR9ewfYuRZ+XeTeS2f9KNhzv3InZHeHLzzpz5QmQQh/27dDJ9JI/W8R6RO5IyJ9ReR53yLqShb/1TVuzfh2+y7qA8e4b4EfPueOGYSD+9wFMa8ARp2augQROW+oIDXnB/et95M/d5Onvfrz9h1L9VAPpq6i/xGu9LDoAdi7Pbjz7lgDyx6HKV/quMnBZ4kkiIGquidyR1V3AwGXAzuh2oPuYpJflJyqmROvgZHT4LmbYM/G9h+vJS/OcVU7n/qN+7ZbHsA5Y0mHBAEw9lPuIvfKT2FzOxaUr9gEB3YF258+HZz6LTe9yJu/Cu6cr97lqvJOvi64c3YwiSSIOhFpWH1FREYC/nS67Ure/xuUfwThm5JTJZSRAZ+6B7Qe/vkVf6dxLimGBfe5pDT6VHdxrip30x0HLZIg8nxY/7e1zr3TNfQ+eTXUVLXtGJE1IILowZROBo6BcZ+GBX8IZqW+nWthyd+h6Irg2z06kEQSxHeB10TkIRH5C/AK8B1/w+rk6mrg1Z/BsMnwsST2POo7ytXhrnsFFv4heceNVlUOc7/qBoidcat7LPLtvcK/OWGaVb4Reg2GrJzgz91U975wwa9g+0oo/nHbjrFlCSAweGxSQ+sQpt/glut889f+n+vVn7s2nlOs9BBPIuMgngMmA48CjwDHq6q1QbTHkkdhz4b2tz3EMnkWfOwT8MIt7ltSsj13s+vWd9HvXOMeHOr9kYp2iPLS1FcvRTvyE3D8bHj9l25h+dYqW+Lq5HN6JT20tDfoaFdVt+A+t9yqX3atcyX442dD7yH+nacTSHSyvjpgG1ABHCsiAazI0knV1bpudUMnwJizkn98EfctNivHVXXU1yXv2KuehcV/gWnfgIKiQ49HLtCWIJwzb3e9qp682jXmt8aWJV2veina9Bvh4F548x7/zvHaz92azqd83b9zdBKJTNb337hqpeeBH3i/5/gbVie29DG3EpkfpYeIvKFw7l1ufYQ3fpmcY+7b6QZTDR4HM25q/Fyvwe4DF3SCUHVTHbe1/7pfcnrDp34Lu9e7klyiDux27VJBTLGRrgYfC8dcAG/f689ymrs3uJ5+k7/oPicmrkRKENcDU4ANqnoaMAnYE38XE1Ndret3PWQ8HHWuv+cafwkceyG8/GM3r097PfM/7gN70b1usZJoGZluacygE8SB3W6AULqVIMCNsD7pK64taO1/EtunoYG6C3VxjWXGt+FgpRt8mGyv/cKNfJ/2jeQfuxNKJEFUqWoVgIjkqOoHQABDPDuhZU+4UaN+lh4iRFzf/NwQPPnl9i0Ks/RxWP4knPYdGDIu9jahguATRDr1YIrl9O/DgDHwz2td435LGqbY6GJdXJsaMs4bnf47OJDE76J7NsJ7f4FJX3Az8ZoWJZIgSr2BcnOBF0Tkn4CPK7V3UvV1rvQwaCwc9clgztlzAJz/S/fN9JWftu0YlWXwr/+Bgilw8vXNbxcqCH4sRLqMgWhOdnf41O/ca/jsTS1vX7YUeg+FXimcEyldzLgRqstdVVOyvPYL99tKDwlLpBfTRaq6R1XnAN8H7gc+5Xdgnc7yJ93ygDNudGMWgnL0uTDhctetr/Sd1u2rCvO+5qYE+dTv4k+GFzOVlXoAACAASURBVCpwEw4ms1G8JQ0JIs3aIKIVHA+nfhPe/yt88K/425Z1sRHU8Qyd4Kph37onsdJXS8o3uXnPJn0utdOydDBxr1QikikiH0Tuq+p8VZ2nqraIbWvU18P8n8LAY1wDXNDOucN9M517tRutmqj3HoLV/4Yz5sCAj8XfNlQA9TWwd1t7Im2d8o1uJGy6T5Mw/UZ34X/qeti3I/Y2NQfcnP5duQdTUzNudMlhwX3tP9brd7tBpNO+2f5jdSFxE4Sq1gGrokdSmzZYMRd2rIIZNwRbeojIDcGFv4YdH7pZMxOxewM89x03z9IJV7W8fSrGQkS6uKb7QodZ3VzjflU5PP2N2Kt/bVsJWte1ezA1NWwSHHmW6/LangWNKrbAO39ys5729XEJ104okatVX2C5iLwkIvMiP34H1mlESg8DjoJjU1gzd8RpMOVKeOs3sP61+NvW18M/vwqIm2spkaTWMBYiwHaIdBwD0ZzBY+G0m2HlPNfo31RZgGtAdCQzvu16q7WnFPH6/7lFkU79n+TF1UUkkiC+D5wH3Ab8LOrHJOKDp9zUC9NvCHa92lg+8QM3Hcfca+J/I1twL6x/Fc7+XzfXfSJSMViuvDS92x+aOvk6KDjBdRmu2NL4uS1L3Kp4fUalJLS0VXC8m47mjV9D9d7W719ZBu/8ESZcBv1sbbPWSqSRen6snyCC6/AipYf+R8K4i1MdDXTr6abI2LMRnv9u7G12rHYztR55llslLlG5eZATCi5B1NVA5ZaOU4IA9wXhot+5Lsfzrm1c1RRpoE5FFWS6m3GTm+G2LfOLvfEr916x0kObJDKSulJEKryfKhGpE5GEpu0UkbNFZJWIrBGRw/r5ich0EXlXRGpF5JImz9WJyGLvp2NWaa36l1vtLR1KDxEjTnITlL37J1j9QuPn6mrd9BDZ3eGCX7a+bj/IsRAVmwHtWAkC3DxLn7gN1rzo/gfgen5tXW7VS80ZPsVNif/Gr1o3dcnebbDwfjjus6lZDrQTSKQE0VtV81Q1D+gOfBr4TUv7iUgmcA9wDnAsMFNEjm2y2UfAbCDWKjcHVHWi95OCrj/tpArzfwL9Ct00xukkfLPrUfXPaxtPivb63bBpkVshrS2TmAU5FiLdx0DEM+W/YfR0V4rbvd5Nqliz33owxTPj27B/h1tUKFFv/Arqqt1aE6ZNWrXKu7f06FwRuRVoaeTPCcAaVS0BEJFHgAuBFVHHW+895+PiBSmy6lk38OlTv40/fgCoqaunrr59S2zkZreihJKd66o6/nA6PHsjfPoPLtbiO2Dsxa1OaHX1SoaAhAqgdGErI2+jqDEQDedPUW+mVp8/IwMu/A38ZqqbOv34We7xFPVgqqtXaupS+xHMycqI//qNOAlGz3ANzkVfgm494h9w3w5XJTXukha7aNfXKwfb+fd3y8wgIyM177/6eqWiqoY+Pbq1vHErtZggRCS68jwDKAISWQ0lH4j+OlkKnNiK2HJFZBFQC9yhqnNjxHYVcBXAiBFp1BNXFebf4RqEx3+20VP7qmtZuaWCZZvKWbbZ/V69bW+7E8TA3jmMG5bHuPwQY4eFGJefR36f7s1/6IZNdP3zi3/s2htevxt69HOlhzgOHKxjZVkFyzeVs2xTBcs2l/Ph1kpC3bO5sSd89sAuXli8lqNHDKWgb5zzt1FVTR0flFWiy5YyCbj4r+tZtnU1vXKzGJcfYtywPMbnhxiXH/Ll/NW1dXxYtpdlm8tZuqmc5ZvKWVlWSY9umYwbFmJsvnf+YSFG9OvR/EWjz3A3PuWfX3VTv2d2cz3dfFZTV8+HWytZvqmCpZvc37BySwXVtalNEL1zsxg7LI9xw9z/blx+HqMH9CIz+vUL3wR/PAfeeRCmfiX+Ad/4lRtbMv2GRg/X1NWzZttelm0qZ7n3+VuxpYL9B9s3wLNnt0zvc+diH58fonBgk/iToK5eWbdjL8ui/n8rNldw7LA8/v7lqUk9FyRWgjg/6nYtsB5XEvDbSFXdJCKFwH9EZKmqNlrgQFXvA+4DKCoqatsVtr4enr3Bzc8ybGK7gwbc4LIt77P/nP9j8fo9LPcupMs2lVOyY19D2+SAXt0Ylx/i40cPondu2xeor1dl7fa9LN9UwfwPtxPJNX17ZDdKGIddtE79Jnz4LPzjSkBh5qMuSXgqq2pYsbmCZZu9hLC5nDXb9jYcv1/PbowdlscVp4xm176DrFvfF4A7Hn2JtZpPqHt2w3nHehfvUf17JvxNa290Mt1UwfLNh5Lpj7JWMDIrjx49ejPr5N6UH6hh6aYK7nulhFovwD49shtdtMfnu78/0aQRSUbu/O7vX1VWSU2dO36el5S+eNJI9lbXsmxzOQ+8tq7h+d45WRzrJe3I69DoojHxc7Dyafc/GHLc4ZMgtlMkmS31Yl+2qZwPtlQ2fFvu5cX3uRNHMrB36hZcUpTNew6wdFMFf35rAwe9ZNU9O9O9fsPyvPfPOI4eOY2M1++Gov86tB5JU/t2woLfU3fsRayoHsyyBR81/A9XllU2HL9Ht0yOHZrHZ4uGMygvB6FtF3NFKSuvYummcv66YANVNY3jH58fYuywPMYXhPjYwF5kZSbWEaG2rp612/e5/5/3E53McrIyOGZoHhdNyqdoVN82xd4S0ViDdpJxYJGpwBxVPcu7/x0AVf3fGNs+CDytqjE6iLf8PLgEsWjRolbHuXfzB9T+/hPkaSWv9TyT5wZfifYaTO/cbHrlZNE7N8v7nU3v3MPvR4rGO/dWuxJB6R4++fbnyDm4m1MP3EWtl4OHhnIbXajHF4QY1Dsn6d9wDxys44Oyxhf16Ita04vW5NytjPjHeRw85mIWHfcDlnnfSpZvrmDdjkMNgoPzchpd6Mflhxgaym0c/4Y34Y9ns/bsv/CWHNdwUY++KEW+aY3NP/Rt8YiBPdlXXcfyzZELmUuo6xol0xzG5x8qIc1YeA25B3chX27coa6qpo5VZZXe3+D+lkZ/f26Wd97IaxBidP+eVNfWs2KLi3dpqdsvumTXp0e290EPeSWUvJjJ5mCt9w096u9YuaWi4aKRm53BsUO9cw8LMaFvFWP+cTYy7mK3ZGkbVdXUuWS6uYJlpeUNJbumf/f4Au9ilR9qVbIOSk1dPWu3u2/Iy7z/4fLNhy6K07JX8pfMH/LUsOupnPDfjMvPY8zg3qjS8P/Lf/cuTtv+Fz5Z8xNW1rk2qqb/97HDQowe0DPp3/AjF/VDn6PG8Ucu6pH30Lj8EEcO6o0IrN66t+GLSKRkF51sxg479J4dl5/XqmQTj4i8o6pFMZ9rKUGIyJ+A61V1j3e/L/AzVb2ihf2ygA+B04FNwELgclU9bO7ppgnAO8d+Va0WkQHAm8CFqrqi6b4RbU0Qe/YfZM7f3+CMHQ9x1t651JLFAxkXc1/N2ZTXtFzAys4UcrMzqayqBSCcsZgHu/2Uhwd9kz3HfM57M+YxoFfqvqHFumit2HyoWmFg1n6213YH7xtUQd/uDR+msV78g3rntnyiPR/B3ePdgkWTv9jwcE1dvXvzby73klYFKzZXcKDGfWi6ZWY0qgPO79M96sPgEsmgvCbnv+ck1zPlsocT/vujv4k1/SZZVVPXUDLq37Nbo6qCscPaV11VW1dPyY59DSWhyIVvn3fRGJi5n+zcnhyUbg0dxyJnOnRfmtyPPC+oKlsrq1udzDqK+npl3U73+i3fVM5F719Jv4ObmF71C6rpRlaGUK9KvUKIvbyeez3Le0xh/nF3NiTi4f2SX92YKFctdChpRKq39la7a0a3zAwQGt6PkZKdS+juPXhYdVsStTdBvKeqk1p6rJl9zwXuBjKBB1T1RyJyG7BIVeeJyBTgSdxo7SqgTFXHisjJwL1APa7d425VvT/eudqaIBrZudYt8PLB0xAaTu3H51B5xPlUVtdRWV1DZVUte6tqqayuYW9VLRVVteytrmVfdS3D+/Zg7LDenPDSpWTt3wZfezfpVQbJFH3RWrmlgv69vBLCsDz69mxj3HU1cPsgV+972s3xN42qS12xpeJQddCwPPonkkx/XOAmXjvnJ20KNTpprdhc0VBdNL4gxJC8XN8vJvX1yvqd+1xJb3M5lVW1UcMi3I3I/YbfTR/n0PNDQjlJSWYdQkkx/PlCds/4MW8NuJhlm8vJzMhgfH6Ikzb8lt5v/wKueSOt1/Wur1c27Nrf0I6lkLKSXXsTxPtAWFV3e/f7AfNVNa06bSclQUSse8Wtvbx1KQw/Cc7+MeQf3/J+a16Cv1wM5/0CiuIWsDqvnx8LhWE3RYdfqsrhjhFuac+Tv+bfeUx6UoUHznZdqq97zy2vC25KjruPc++/Sx9KZYQdSrwEkUgF1s+AN0XkhyLyQ+ANoI2LC3QQo6fDl+e7qpJdJfD7j8M/vuwNzmpGZNxDXr5rfOyqghgL0ZHHQJj2E3EzvVZscgsARbx9L1RXuOdMUiQyUO7PwMXAVu/nYlXt/Ok5I9PVo3/tHbfAyPIn4VfHQ/FP4OD+w7dfNx82vu22zUpde0PKBTGauiOsA2H8dcTH3SJWr/3CTV1SVe4mojz6PBuRnkSJTLVxErBRVX+tqr/GrTDXmvEMHVtunlsP4doFcOSZbtzAr4tgyd9dF1lwpYfin7h1maMaZ7ukUIFbnKXex371kRKKlSC6LhE3R1P5RrcY09v3uSRhpYekSqSK6bdA9DSKe73Hupa+o+Czf4L/ehZ6DnRjB+7/BGxc4KbP/ugNmPb1rl16APetvq7aTYvgl/JSyMiGnoP8O4dJfx87HYZNhld+Bm/+Gsac41aiM0mTSIIQjWrJVtV6WjlFR6cy8mS48mU3hUZ5qUsSj82CXkNg8qxUR5d6QawLUV7qFp23mU+7NhE3urr8I6jaY6UHHyTyCSsRketEJNv7uR4o8TuwtJaRARMvd+0T0290bRLhm9wcR11dEOtCdLR1IIx/jjwTRkx1S/nmT051NJ1OIiWBq4FfAt/Ddb1+CbjSz6A6jJxe8PHvQvg79m02IqgEMWqaf8c3HYcIzH4m1VF0Wi0mCFXdBlwWuS8i3XErzD3mY1wdiyWHQ3L7QLde/iWIulrX3dgaqE2Eff58k9ArKyKZInKuiDwErAMu9Tcs02GJ+DsWYm8ZaJ0lCGMCELcEISIzgMuBc4EFwClAoarGGAhgjMfPsRA2SM6YwDRbghCRUuB/gdeAY1X107hV3iw5mPgCSRDWSG2M3+JVMT0ODMNVJ50vIj05ND+YMc0LFcC+7VCTyLpSrRSpusrLT/6xjTGNNJsgVPXrwGjcXExhYBUwUEQ+KyK9ggnPdEiRb/cVm5J/7PJS6N7X9SAzxvgqbiO1Oi+r6lW4ZDETt5rc+gBiMx1V5Nu9H9VM5aXW/mBMQBIeEa2qNcDTwNNeV1djYvNzLIQNkjMmMG3qQKyqB5IdiOlE8oYB4lOC2GglCGMCYiNMTPJl5UCvwckfC1Fd6WbstARhTCAsQRh/+NHVtXzToWMbY3zXYhuEiDzF4d1by4FFwL2q6kNfRtPhhQpg6/LkHtPGQBgTqIRmc8WtAfF776cCqATGePeNOVykBNHCmuetYgsFGROoRHoxnayqU6LuPyUiC1V1iogk+Sui6TRCw6H2AOzfBT37J+eY5aUgmdB7SHKOZ4yJK5ESRC8RGRG5492OjFI66EtUpuPzY+Gg8lI3xiIjM3nHNMY0K5ESxP8Ar4nIWkBwA+a+4k298Sc/gzMdWPRYiGETk3NMGyRnTKASWQ/iGRE5Ejjae2hVVMP03b5FZjq2SENyMnsylW+E4Scm73jGmLgSHUl9PDDK236CiKCqf/YtKtPx9egHWd2TV8VUX2cLBRkTsES6uT4EHAEsBuq8hxWwBGGa17BwUJJKEHu3QX2NJQhjApRICaIItx6ETfVtWieZCcLGQBgTuER6MS0DrF+hab2kJggbA2FM0BIpQQwAVojIAqA68qCqXuBbVKZzCA2HvVuh9iBkdWvfsWypUWMCl0iCmON3EKaTCuUDCpWboe+o9h2rvBRyQpCbl4zIjDEJSKSb6/wgAjGdUPRYiGQkiJAtM2pMkJpNECLymqpOE5FKGk/WJ7jF5uyrnIkvmWMhbB0IYwLXbIJQ1Wne797BhWM6lbxh7ncyxkKUl0JBUfuPY4xJWEID5UQkExgcvb2qfuRXUKaTyO4OPQe2vwRxcB8c2GUlCGMC1mI3VxH5GrAVeAH4l/fzdCIHF5GzRWSViKwRkZtiPD9dRN4VkVoRuaTJc7NEZLX3Myuhv8akn2R0dW1YKMjGQBgTpERKENcDR6nqztYc2Ct13AN8AigFForIPFVdEbXZR8Bs4FtN9u0H3IobpKfAO96+u1sTg0kDoQLYsbp9x6iwLq7GpEIiA+U24laQa60TgDWqWqKqB4FHgAujN1DV9aq6BKhvsu9ZwAuqustLCi8AZ7chBpNqoeHtXzjIxkAYkxKJlCBKgGIR+ReNB8r9vIX98nHJJaIUSHQqzlj7HtbHUUSuAq4CGDFiRNOnTToIFcDBvVC1B7r3bdsxyktBMqD30OTGZoyJK5ESxEe4b/DdgN5RPymnqvepapGqFg0cODDV4ZhYosdCtFV5qUsOmdnJickYk5BEBsr9oI3H3gREtyoWeI8lum+4yb7FbYzDpFJ0ghgyvm3HsDEQxqREvIFyd6vq10XkKRoPlAMSmotpIXCkiIzGXfAvAy5PMK7ngR+LSKRO4kzgOwnua9JJMgbLlZfCsEnJiccYk7B4JYiHvN93teXAqlorItfiLvaZwAOqulxEbgMWqeo8EZkCPAn0Bc4XkR+o6lhV3SUiP8QlGYDbVHVXW+IwKdZjAGTmtH2wXH296+Z6zPnJjcsY06J4I6nf8X63eS4mVX0GeKbJY7dE3V6Iqz6Kte8DwANtPbdJExkZbg6ltpYg9u+AumobA2FMCiSyotyRwP8CxwK5kcdVtdDHuExn0p7BcrYOhDEpk0gvpj8CvwVqgdNwS43+xc+gTCeTV3BoNHRr2RgIY1ImkQTRXVVfAkRVN6jqHOCT/oZlOpVQgVsToq629ftGEkSeTfVtTNASGShXLSIZwGqv0XkT0MvfsEynEioArYfKLdCnlW0J5aWQ3bPtg+yMMW2WSAnieqAHcB1wPPB5wCbPM4lrz2C5yBgIkeTGZIxpUdwShDfh3qWq+i1gL/BfgURlOpf2jIUoL7X2B2NSpNkShIhkqWodMC3AeExnFFkqtC1jISxBGJMy8UoQC4DJwHsiMg94DNgXeVJV/+FzbKaz6NYTuvdrfQmi5gDs225jIIxJkUQaqXOBncDHcVNuiPfbEoRJXFvGQlRsPrSvMSZw8RLEIBH5JrCMQ4khoh2T+5suKTQcdq9v3T42SM6YlIqXIDJx3VljdR+xBGFaJ1QA619r3T4NS41agjAmFeIliC2qeltgkZjOLVQA1eVQVQ65ocT2KS8FBPKG+RqaMSa2eOMgrOO5SZ6GsRCtmHKjfCP0GgxZOf7EZIyJK16COD2wKEzn15axENbF1ZiUajZB2PoLJqkaShCtGAthCcKYlEpkqg1j2q/XYMjITrwEoWoJwpgUswRhgpGR4RqbKxJsg9i/C2oP2CA5Y1LIEoQJTmsGy9kYCGNSzhKECU6oIPE2iIaFgmwdCGNSxRKECU6owE2fUV/X8rYNCcKqmIxJFUsQJjihAqivhb1bW962fCNk5UKP/v7HZYyJyRKECU5rxkJEejDZQkHGpIwlCBOc1oyFsC6uxqScJQgTnLzIwkGtKEEYY1LGEoQJTm6em6ivpQRRWw17y6yB2pgUswRhghUa3nKCsIWCjEkLliBMsBIZC9HQxdUShDGpZAnCBCuR0dQ2BsKYtGAJwgQrVAAHdkP13ua3qfAShC0UZExKWYIwwYqUCuJN2ldeCj0HQnb3YGIyxsRkCcIEK5GxENbF1Zi0YAnCBKshQcRph7AEYUxasARhgtVrCEhm82tTNywUZA3UxqSaJQgTrMws6D20+RJE1R44uPfQqGtjTMr4miBE5GwRWSUia0TkphjP54jIo97zb4vIKO/xUSJyQEQWez+/8zNOE7B4YyFsDIQxaSPLrwOLSCZwD/AJoBRYKCLzVHVF1GZfAnar6sdE5DLgJ8Cl3nNrVXWiX/GZFAoVwKZ3Yj9nYyCMSRt+liBOANaoaomqHgQeAS5sss2FwJ+8248Dp4vY/M6dXqjAdXOtrz/8OStBGJM2/EwQ+UB0PUKp91jMbVS1FigHIivEjBaR90RkvoicGusEInKViCwSkUXbt29PbvTGP6ECqDsI+2L8z8o3QmY3Nw7CGJNS6dpIvQUYoaqTgG8CfxWRvKYbqep9qlqkqkUDB9oFpcOIt3BQealroM5I17emMV2Hn5/CTUB0RXKB91jMbUQkCwgBO1W1WlV3AqjqO8BaYIyPsZogxRssZ2MgjEkbfiaIhcCRIjJaRLoBlwHzmmwzD5jl3b4E+I+qqogM9Bq5EZFC4EigxMdYTZDiDZazMRDGpA3fejGpaq2IXAs8D2QCD6jqchG5DVikqvOA+4GHRGQNsAuXRACmA7eJSA1QD1ytqrv8itUELDcE3XofniDqaqByi5UgjEkTviUIAFV9BnimyWO3RN2uAj4TY78ngCf8jM2kkEjssRCVW0DrLUEYkyasJdCkRqx1IayLqzFpxRKESY24CcLaIIxJB5YgTGqECmD/Dqg5cOixSJVTyOZhMiYdWIIwqdEwFiKq53P5JujeD7r1TE1MxphGLEGY1Ig1FsLGQBiTVixBmNSIJILopUdtDIQxacUShEmNvGGANG6oLi+19gdj0oglCJMamdnQe8ihKqaqcqgutyomY9KIJQiTOtFdXSON1ZYgjEkbliBM6jRKEDYGwph0YwnCpE4kQahGjYGwEoQx6cIShEmd0HCorYL9O12iyMiCXoNTHZUxxmMJwqRO9FiI8lLXsykjM7UxGWMaWIIwqRO9LoSNgTAm7ViCMKkTvfSojaI2Ju1YgjCp070vZPeA3RvciGpLEMakFUsQJnUiCwdtWgRaZwnCmDRjCcKkVqgANi/2blsbhDHpxBKESa1QAdTXHLptjEkbliBMakWXGvJsoj5j0oklCJNakVJDbghy81IbizGmEUsQJrUiCcLaH4xJO5YgTGpFqpWsesmYtGMJwqRWJDFYA7UxaScr1QGYLi47F878EYyalupIjDFNWIIwqXfytamOwBgTg1UxGWOMickShDHGmJgsQRhjjInJEoQxxpiYLEEYY4yJyRKEMcaYmCxBGGOMickShDHGmJhEVVMdQ1KIyHZgQzsOMQDYkaRw/GDxtY/F1z4WX/ukc3wjVXVgrCc6TYJoLxFZpKpFqY6jORZf+1h87WPxtU+6x9ccq2IyxhgTkyUIY4wxMVmCOOS+VAfQAouvfSy+9rH42ifd44vJ2iCMMcbEZCUIY4wxMVmCMMYYE1OXShAicraIrBKRNSJyU4znc0TkUe/5t0VkVICxDReRl0VkhYgsF5HrY2wTFpFyEVns/dwSVHxRMawXkaXe+RfFeF5E5Jfea7hERCYHGNtRUa/NYhGpEJGvN9km0NdQRB4QkW0isizqsX4i8oKIrPZ+921m31neNqtFZFaA8d0pIh94/78nRaRPM/vGfS/4GN8cEdkU9T88t5l9437efYzv0ajY1ovI4mb29f31azdV7RI/QCawFigEugHvA8c22eYrwO+825cBjwYY31Bgsne7N/BhjPjCwNMpfh3XAwPiPH8u8CwgwEnA2yn8f5fhBgGl7DUEpgOTgWVRj/0UuMm7fRPwkxj79QNKvN99vdt9A4rvTCDLu/2TWPEl8l7wMb45wLcS+P/H/bz7FV+T538G3JKq16+9P12pBHECsEZVS1T1IPAIcGGTbS4E/uTdfhw4XUQkiOBUdYuqvuvdrgRWAvlBnDvJLgT+rM5bQB8RGZqCOE4H1qpqe0bXt5uqvgLsavJw9PvsT8CnYux6FvCCqu5S1d3AC8DZQcSnqv9W1Vrv7ltAQbLPm6hmXr9EJPJ5b7d48XnXjs8Cf0v2eYPSlRJEPrAx6n4ph1+AG7bxPiDlQP9AooviVW1NAt6O8fRUEXlfRJ4VkbGBBuYo8G8ReUdErorxfCKvcxAuo/kPZqpfw8GqusW7XQYMjrFNuryOV+BKhLG09F7w07VeFdgDzVTRpcPrdyqwVVVXN/N8Kl+/hHSlBNEhiEgv4Ang66pa0eTpd3FVJhOAXwFzg44PmKaqk4FzgK+KyPQUxBCXiHQDLgAei/F0OryGDdTVNaRlX3MR+S5QCzzczCapei/8FjgCmAhswVXjpKOZxC89pP1nqSsliE3A8Kj7Bd5jMbcRkSwgBOwMJDp3zmxccnhYVf/R9HlVrVDVvd7tZ4BsERkQVHzeeTd5v7cBT+KK8tESeZ39dg7wrqpubfpEOryGwNZItZv3e1uMbVL6OorIbOA84HNeEjtMAu8FX6jqVlWtU9V64PfNnDfVr18WcDHwaHPbpOr1a42ulCAWAkeKyGjvG+ZlwLwm28wDIr1FLgH+09yHI9m8+sr7gZWq+vNmthkSaRMRkRNw/78gE1hPEekduY1rzFzWZLN5wBe93kwnAeVR1SlBafabW6pfQ0/0+2wW8M8Y2zwPnCkifb0qlDO9x3wnImcDNwIXqOr+ZrZJ5L3gV3zRbVoXNXPeRD7vfjoD+EBVS2M9mcrXr1VS3Uoe5A+uh82HuN4N3/Ueuw33QQDIxVVLrAEWAIUBxjYNV9WwBFjs/ZwLXA1c7W1zLbAc1yPjLeDkgF+/Qu/c73txRF7D6BgFuMd7jZcCRQHH2BN3wQ9FPZay1xCXqLYANbh68C/h2rVeAlYDLwL9vG2LgD9E7XuF915cA/xXgPGtwdXfR96HkZ59w4Bn4r0XAorvIe+9tQR30R/aND7v/mGf9yDi8x5/ThmdVwAAAm9JREFUMPKei9o28NevvT821YYxxpiYulIVkzHGmFawBGGMMSYmSxDGGGNisgRhjDEmJksQxhhjYrIEYYxHRPZ6v0eJyOVJPvbNTe6/kczjG+MHSxDGHG4U0KoE4Y2cjadRglDVk1sZkzGBswRhzOHuAE715un/hohkemskLPQmiPsyNKwt8aqIzANWeI/N9SZfWx6ZgE1E7gC6e8d72HssUloR79jLvLUBLo06drGIPC5ubYaHo0aA3yFu3ZAlInJX4K+O6TJa+tZjTFd0E269gfMAvAt9uapOEZEc4HUR+be37WRgnKqu8+5foaq7RKQ7sFBEnlDVm0TkWlWdGONcF+MmnZsADPD2ecV7bhIwFtgMvA6cIiIrcdNLHK2qKs0s5mNMMlgJwpiWnYmbX2oxbgr2/sCR3nMLopIDwHUiEpnGY3jUds2ZBvxN3eRzW4H5wJSoY5eqm5RuMa7qqxyoAu4XkYuBmHMlGZMMliCMaZkAX1PVid7PaFWNlCD2NWwkEsZN0jZV3XTi7+Hm92qr6qjbdbhV3mpxs34+jptt9bl2HN+YuCxBGHO4StyyrxHPA9d407EjImO8GTibCgG7VXW/iByNW3I1oiayfxOvApd67RwDcUtYLmguMG+9kJC6qcq/gauaMsYX1gZhzOGWAHVeVdGDwP/hqnfe9RqKtxN7mdDngKu9doJVuGqmiPuAJSLyrqp+LurxJ4GpuFk9FbhRVcu8BBNLb+CfIpKLK9l8s21/ojEts9lcjTHGxGRVTMYYY2KyBGGMMSYmSxDGGGNisgRhjDEmJksQxhhjYrIEYYwxJiZLEMYYY2L6fzLIvcnwRY8KAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 0.149128869166697\n",
            "Final Validation Accuracy: 0.1744218445249373\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def train2(model, train_data, val_data, batch_size=3000, num_epochs=5, lr = 0.01):\n",
        "    \n",
        "    num_workers = 1\n",
        "    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, \n",
        "                                           num_workers=num_workers, shuffle=True)\n",
        "    val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, \n",
        "                                          num_workers=num_workers, shuffle=True)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9,weight_decay=5e-4)\n",
        "\n",
        "    iters, losses, train_acc, val_acc = [], [], [], []\n",
        "\n",
        "    # training\n",
        "    n = 0 # the number of iterations\n",
        "    for epoch in range(num_epochs):\n",
        "        print(\"Epoch\", epoch)\n",
        "        n = 0\n",
        "        for imgs, labels in iter(train_loader):\n",
        "            # print(\"iteration \", n)\n",
        "\n",
        "            if use_cuda and torch.cuda.is_available():\n",
        "                imgs = imgs.cuda()\n",
        "                labels = labels.cuda()\n",
        "\n",
        "            out = model(imgs)             # forward pass\n",
        "\n",
        "            loss = criterion(out, labels) # compute the total loss\n",
        "            loss.backward()               # backward pass (compute parameter updates)\n",
        "            optimizer.step()              # make the updates for each parameter\n",
        "            optimizer.zero_grad()         # a clean up step for PyTorch\n",
        "            n += 1\n",
        "\n",
        "        # save the current training information\n",
        "        iters.append(epoch)\n",
        "        losses.append(float(loss)/batch_size)             # compute *average* loss\n",
        "        # calculate accuracy at each epoch instead of iteration\n",
        "        # def get_accuracy(model, data):\n",
        "        train_acc.append(get_accuracy(model, train_loader)) # compute training accuracy \n",
        "        # compute validation acc every epoch\n",
        "        val_acc.append(get_accuracy(model, val_loader))  # compute validation accuracy\n",
        "        print(\"Epoch: \", epoch, \" Train Accuracy: \", train_acc[epoch])\n",
        "        print(\"Epoch: \", epoch, \" Validation Accuracy: \", val_acc[epoch])\n",
        "\n",
        "            \n",
        "\n",
        "    # plotting\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, losses, label=\"Train\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.show()\n",
        "\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, train_acc, label=\"Train\")\n",
        "    plt.plot(iters, val_acc, label=\"Validation\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Training Accuracy\")\n",
        "    plt.legend(loc='best')\n",
        "    plt.show()\n",
        "\n",
        "    print(\"Final Training Accuracy: {}\".format(train_acc[-1]))\n",
        "    print(\"Final Validation Accuracy: {}\".format(val_acc[-1]))"
      ],
      "metadata": {
        "id": "5rDhJ_gXQwKs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#train\n",
        "model6 = CNN2()\n",
        "use_cuda = True\n",
        "model6.cuda()\n",
        "\n",
        "train2(model6, train_data, val_data, batch_size = 500,lr=0.05,num_epochs=10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "0HHg7uf7Okgq",
        "outputId": "ae7d736f-5018-495a-a537-8258f90cb274"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  0  Validation Accuracy:  0.1721928113680691\n",
            "Epoch 1\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  1  Validation Accuracy:  0.2148230704931736\n",
            "Epoch 2\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  2  Validation Accuracy:  0.18250208971858456\n",
            "Epoch 3\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  3  Validation Accuracy:  0.2585678461967122\n",
            "Epoch 4\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  4  Validation Accuracy:  0.24853719699080523\n",
            "Epoch 5\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  5  Validation Accuracy:  0.27667874059626635\n",
            "Epoch 6\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  6  Validation Accuracy:  0.2956255224296461\n",
            "Epoch 7\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  7  Validation Accuracy:  0.29590415157425465\n",
            "Epoch 8\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  8  Validation Accuracy:  0.1744218445249373\n",
            "Epoch 9\n",
            "iteration  0\n",
            "iteration  1\n",
            "iteration  2\n",
            "iteration  3\n",
            "iteration  4\n",
            "iteration  5\n",
            "iteration  6\n",
            "iteration  7\n",
            "iteration  8\n",
            "iteration  9\n",
            "iteration  10\n",
            "iteration  11\n",
            "iteration  12\n",
            "iteration  13\n",
            "iteration  14\n",
            "iteration  15\n",
            "iteration  16\n",
            "iteration  17\n",
            "iteration  18\n",
            "iteration  19\n",
            "iteration  20\n",
            "iteration  21\n",
            "iteration  22\n",
            "iteration  23\n",
            "iteration  24\n",
            "iteration  25\n",
            "iteration  26\n",
            "iteration  27\n",
            "iteration  28\n",
            "iteration  29\n",
            "iteration  30\n",
            "iteration  31\n",
            "iteration  32\n",
            "iteration  33\n",
            "iteration  34\n",
            "iteration  35\n",
            "iteration  36\n",
            "iteration  37\n",
            "iteration  38\n",
            "iteration  39\n",
            "iteration  40\n",
            "iteration  41\n",
            "iteration  42\n",
            "iteration  43\n",
            "iteration  44\n",
            "iteration  45\n",
            "iteration  46\n",
            "iteration  47\n",
            "iteration  48\n",
            "iteration  49\n",
            "iteration  50\n",
            "iteration  51\n",
            "iteration  52\n",
            "iteration  53\n",
            "iteration  54\n",
            "Epoch:  9  Validation Accuracy:  0.14711618835330176\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 0.14549157967482632\n",
            "Final Validation Accuracy: 0.14711618835330176\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#train\n",
        "model7 = CNN2()\n",
        "use_cuda = True\n",
        "model7.cuda()\n",
        "\n",
        "train2(model7, train_data, val_data, batch_size = 100,lr=0.01,num_epochs=15)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "lnybKCJRXiSt",
        "outputId": "9aa79d49-9260-4e15-e451-2d0c0c83d572"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  0  Train Accuracy:  0.23427781617138907\n",
            "Epoch:  0  Validation Accuracy:  0.16383393702981333\n",
            "Epoch 1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  1  Train Accuracy:  0.26061179209253266\n",
            "Epoch:  1  Validation Accuracy:  0.17915853998328224\n",
            "Epoch 2\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  2  Train Accuracy:  0.3048776052085986\n",
            "Epoch:  2  Validation Accuracy:  0.21955976595151852\n",
            "Epoch 3\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  3  Train Accuracy:  0.31811733895900773\n",
            "Epoch:  3  Validation Accuracy:  0.2585678461967122\n",
            "Epoch 4\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  4  Train Accuracy:  0.3361219219437675\n",
            "Epoch:  4  Validation Accuracy:  0.24129283923098357\n",
            "Epoch 5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  5  Train Accuracy:  0.3515440293892991\n",
            "Epoch:  5  Validation Accuracy:  0.28280858177765394\n",
            "Epoch 6\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  6  Train Accuracy:  0.3619466773360492\n",
            "Epoch:  6  Validation Accuracy:  0.2822513234884369\n",
            "Epoch 7\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  7  Train Accuracy:  0.36689339104499324\n",
            "Epoch:  7  Validation Accuracy:  0.2942323767066035\n",
            "Epoch 8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  8  Train Accuracy:  0.3848252282399156\n",
            "Epoch:  8  Validation Accuracy:  0.3101142379492895\n",
            "Epoch 9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  9  Train Accuracy:  0.3914450951151202\n",
            "Epoch:  9  Validation Accuracy:  0.3290610197826693\n",
            "Epoch 10\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  10  Train Accuracy:  0.40443021860109846\n",
            "Epoch:  10  Validation Accuracy:  0.3282251323488437\n",
            "Epoch 11\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  11  Train Accuracy:  0.39235441748808786\n",
            "Epoch:  11  Validation Accuracy:  0.3379771524101421\n",
            "Epoch 12\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  12  Train Accuracy:  0.4218528352671589\n",
            "Epoch:  12  Validation Accuracy:  0.3424352187238785\n",
            "Epoch 13\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  13  Train Accuracy:  0.4147237478630924\n",
            "Epoch:  13  Validation Accuracy:  0.3602674839788242\n",
            "Epoch 14\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n",
            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7fb8550aa560>\n",
            "Traceback (most recent call last):\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n",
            "    self._shutdown_workers()\n",
            "  File \"/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n",
            "    if w.is_alive():\n",
            "  File \"/usr/lib/python3.7/multiprocessing/process.py\", line 151, in is_alive\n",
            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
            "AssertionError: can only test a child process\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:  14  Train Accuracy:  0.44695013276106643\n",
            "Epoch:  14  Validation Accuracy:  0.36695458344942883\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 0.44695013276106643\n",
            "Final Validation Accuracy: 0.36695458344942883\n"
          ]
        }
      ]
    }
  ]
}