Other_Models.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eu8ipDOgI0XV",
        "outputId": "7a11eeea-48a6-4533-c8f7-06150331f8ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive \n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Dataset Preperation**"
      ],
      "metadata": {
        "id": "9USq3iLEXyeH"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BZrMn55pJGUA"
      },
      "outputs": [],
      "source": [
        "import torch.nn.functional as F\n",
        "import torch\n",
        "from torch.utils.data import DataLoader, Dataset, ConcatDataset\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import torchvision.transforms as transforms\n",
        "import numpy as np\n",
        "import os\n",
        "import torchvision\n",
        "from tqdm import tqdm\n",
        "from torchvision import datasets, models, transforms \n",
        "from PIL import Image\n",
        "\n",
        "#vgg16 = torchvision.models.vgg16(pretrained=True)\n",
        "\n",
        "class HARDataset(Dataset):\n",
        "    \"\"\"\n",
        "    Custom dataset for HAR images that returns transformed image array and corresponding class\n",
        "    \"\"\"\n",
        "    \n",
        "    def __init__(self, data, img_dir, transform=None):\n",
        "        \"\"\"\n",
        "        Inputs:\n",
        "            data (list): 2D list in the form of [[class, file_name]]\n",
        "            img_dir (String): directory of the folder with all the images\n",
        "            transform (torchvision.transforms): transformation to be applied to images\n",
        "        \"\"\"\n",
        "        self.data = np.array(data)\n",
        "        self.img_dir = img_dir\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "    \n",
        "    def __getitem__(self, idx):\n",
        "        if torch.is_tensor(idx):\n",
        "            idx = idx.tolist()\n",
        "        \n",
        "        image_name = os.path.join(self.img_dir, self.data[idx, 1])\n",
        "        img_class = int(self.data[idx, 0])\n",
        "        image = plt.imread(image_name)\n",
        "        if self.transform:\n",
        "            image = self.transform(np.array(image))\n",
        "        \n",
        "        img_one_hot = torch.zeros(15)\n",
        "        img_one_hot[img_class] = 1\n",
        "        sample = {'image': image, 'img_class': img_one_hot}\n",
        "        return sample\n",
        "\n",
        "def filename_loader():\n",
        "    \"\"\"\n",
        "    Helper function that loads image file name and corresponding class from 'Human Action Recognition' folder\n",
        "    \"\"\"\n",
        "    train = pd.read_csv('/content/drive/My Drive/Human Action Recognition/Training_set.csv')\n",
        "\n",
        "    # one-hot encoding not needed for nn.CrossEntropyLoss()(x,y)\n",
        "    # y is the index for the class (0 to 14) and x is the output from the model without sigmoid (1x15 tensor)\n",
        "    classes = {\n",
        "        \"sitting\":0,\n",
        "        \"using_laptop\":1,\n",
        "        \"hugging\":2,\n",
        "        \"sleeping\":3,\n",
        "        \"drinking\":4,\n",
        "        \"clapping\":5,\n",
        "        \"dancing\":6,\n",
        "        \"cycling\":7,\n",
        "        \"calling\":8,\n",
        "        \"laughing\":9,\n",
        "        \"eating\":10,\n",
        "        \"fighting\":11,\n",
        "        \"listening_to_music\":12,\n",
        "        \"running\":13,\n",
        "        \"texting\":14,\n",
        "    }\n",
        "    images = {\n",
        "        0:[],\n",
        "        1:[],\n",
        "        2:[],\n",
        "        3:[],\n",
        "        4:[],\n",
        "        5:[],\n",
        "        6:[],\n",
        "        7:[],\n",
        "        8:[],\n",
        "        9:[],\n",
        "        10:[],\n",
        "        11:[],\n",
        "        12:[],\n",
        "        13:[],\n",
        "        14:[]\n",
        "    }\n",
        "    train_images = []\n",
        "    val_images = []\n",
        "\n",
        "    for _, data in train.iterrows():\n",
        "        img_class = classes[data[1]]\n",
        "        images[img_class].append([img_class, data[0]])\n",
        "    \n",
        "    for img_class, imgs in images.items():\n",
        "        train_split = int(len(imgs) * 0.8) # 80/20 training/validation split for each class\n",
        "        train_images += imgs[:train_split]\n",
        "        val_images += imgs[train_split:]\n",
        "\n",
        "    return train_images, val_images\n",
        "\n",
        "def data_loader(batch_size=64, shuffle=True, num_workers=0):\n",
        "    \"\"\"\n",
        "    Returns DataLoader objects for train and validation data\n",
        "    \"\"\"\n",
        "    train_images, val_images = filename_loader()\n",
        "\n",
        "    # normalize the pixel values to between 0 and 1 and crop to same size for DataLoader to work\n",
        "    img_dir = '/content/drive/My Drive/Human Action Recognition/train'\n",
        "    \n",
        "    transform = transforms.Compose([transforms.ToTensor(), \n",
        "                                    transforms.Resize((224,224)),\n",
        "                                    transforms.CenterCrop(224),\n",
        "                                    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n",
        "    # Resize and crop images into size 224 x 224\n",
        "\n",
        "    val_dataset = HARDataset(data=val_images, img_dir=img_dir, transform=transform)\n",
        "    train_dataset = HARDataset(data=train_images, img_dir=img_dir, transform=transform)\n",
        "\n",
        "    val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)\n",
        "    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)\n",
        "    return train_loader, val_loader"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Training**"
      ],
      "metadata": {
        "id": "GqREgTUJX6LU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kAfowizNRy8l"
      },
      "outputs": [],
      "source": [
        "#from preprocessing import data_loader\n",
        "#from model import CNN\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "def train(net, train_loader, val_loader, batch_size=32, lr=0.001, num_epochs=30):\n",
        "    # Fixed PyTorch random seed for reproducible result\n",
        "    torch.manual_seed(0)\n",
        "\n",
        "    if torch.cuda.is_available():\n",
        "        net = net.cuda()\n",
        "\n",
        "    # cross entropy loss function and adaptive moment estimation optimizer\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.AdamW(net.parameters(), lr = lr, weight_decay=0.1)\n",
        "\n",
        "    # softmax for predictions\n",
        "    softmax = nn.Softmax(dim = 1)\n",
        "    \n",
        "    # initialize error and loss history\n",
        "    train_err = np.zeros(num_epochs)\n",
        "    train_loss = np.zeros(num_epochs)\n",
        "    val_err = np.zeros(num_epochs)\n",
        "    val_loss = np.zeros(num_epochs)\n",
        "\n",
        "    for epoch in tqdm(range(num_epochs)):\n",
        "        total_train_loss = 0.0\n",
        "        total_train_err = 0.0\n",
        "        train_iters = 0\n",
        "\n",
        "        total_val_loss = 0.0\n",
        "        total_val_err = 0.0\n",
        "        val_iters = 0\n",
        "        \n",
        "        train_batches = 0\n",
        "        net.train()\n",
        "        for batch in train_loader:\n",
        "            train_batches += 1\n",
        "            imgs, labels = batch.values()\n",
        "            if torch.cuda.is_available():\n",
        "                imgs = imgs.cuda()\n",
        "                labels = labels.cuda()\n",
        "            optimizer.zero_grad()\n",
        "            outputs = net(imgs)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            pred = softmax(outputs)\n",
        "            # find error and loss for training data\n",
        "            total_train_err += (np.argmax(pred.detach().cpu(), 1) != np.argmax(labels.cpu(), 1)).sum().item()\n",
        "            total_train_loss += loss.item()\n",
        "            train_iters += len(labels)\n",
        "\n",
        "        val_batches = 0\n",
        "        net.eval()\n",
        "        for batch in val_loader:\n",
        "            val_batches += 1\n",
        "            imgs, labels = batch.values()\n",
        "            if torch.cuda.is_available():\n",
        "                imgs = imgs.cuda()\n",
        "                labels = labels.cuda()\n",
        "            outputs = net(imgs)\n",
        "            loss = criterion(outputs, labels)\n",
        "\n",
        "            pred = softmax(outputs)\n",
        "\n",
        "            # find error and loss for training data\n",
        "            total_val_err += (np.argmax(pred.detach().cpu(), 1) != np.argmax(labels.cpu(), 1)).sum().item()\n",
        "            total_val_loss += loss.item()\n",
        "            val_iters += len(labels)\n",
        "\n",
        "        # record the average error (per iteration) and loss (per batch) for each epoch\n",
        "        train_err[epoch] = total_train_err / train_iters\n",
        "        train_loss[epoch] = total_train_loss / train_batches\n",
        "        val_err[epoch] = total_val_err / val_iters\n",
        "        val_loss[epoch] = total_val_loss / val_batches\n",
        "        print(f\"Epoch {epoch}: Train err: {train_err[epoch]} Val err: {val_err[epoch]} Train loss: {train_loss[epoch]} Val loss: {val_loss[epoch]}\")\n",
        "        # save model\n",
        "        model_path = \"/content/drive/My Drive/Human Action Recognition/vgg_model/bs{}_lr{}_epoch{}\".format(batch_size,\n",
        "                                              lr,\n",
        "                                              epoch)\n",
        "        torch.save(net.state_dict(), model_path)\n",
        "    return train_err, train_loss, val_err, val_loss"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Evaluate performance (validation)**"
      ],
      "metadata": {
        "id": "C_R75avnYB1b"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XHT1QSxCC-Yl"
      },
      "outputs": [],
      "source": [
        "def performance_per_class(net):\n",
        "    net.eval()\n",
        "    _, val_loader = data_loader(batch_size=1)\n",
        "    errors = {\n",
        "        0:0,\n",
        "        1:0,\n",
        "        2:0,\n",
        "        3:0,\n",
        "        4:0,\n",
        "        5:0,\n",
        "        6:0,\n",
        "        7:0,\n",
        "        8:0,\n",
        "        9:0,\n",
        "        10:0,\n",
        "        11:0,\n",
        "        12:0,\n",
        "        13:0,\n",
        "        14:0,\n",
        "    }\n",
        "    total = {\n",
        "        0:0,\n",
        "        1:0,\n",
        "        2:0,\n",
        "        3:0,\n",
        "        4:0,\n",
        "        5:0,\n",
        "        6:0,\n",
        "        7:0,\n",
        "        8:0,\n",
        "        9:0,\n",
        "        10:0,\n",
        "        11:0,\n",
        "        12:0,\n",
        "        13:0,\n",
        "        14:0,\n",
        "    }\n",
        "    wrong_guesses = {\n",
        "        0:0,\n",
        "        1:0,\n",
        "        2:0,\n",
        "        3:0,\n",
        "        4:0,\n",
        "        5:0,\n",
        "        6:0,\n",
        "        7:0,\n",
        "        8:0,\n",
        "        9:0,\n",
        "        10:0,\n",
        "        11:0,\n",
        "        12:0,\n",
        "        13:0,\n",
        "        14:0,\n",
        "    }\n",
        "    guesses = {\n",
        "        0:0,\n",
        "        1:0,\n",
        "        2:0,\n",
        "        3:0,\n",
        "        4:0,\n",
        "        5:0,\n",
        "        6:0,\n",
        "        7:0,\n",
        "        8:0,\n",
        "        9:0,\n",
        "        10:0,\n",
        "        11:0,\n",
        "        12:0,\n",
        "        13:0,\n",
        "        14:0,\n",
        "    }\n",
        "    softmax = nn.Softmax(dim = 1)\n",
        "    for batch in val_loader:\n",
        "        img, label = batch.values()\n",
        "        output = softmax(net(img))\n",
        "        pred = np.argmax(output.detach()).item()\n",
        "        truth = np.argmax(label).item()\n",
        "        if pred != truth:\n",
        "            errors[truth] += 1\n",
        "            wrong_guesses[pred] += 1\n",
        "        total[truth] += 1\n",
        "        guesses[pred] += 1\n",
        "    for i in range(15):\n",
        "        wrong_guesses[i] /= guesses[i]\n",
        "        errors[i] /= total[i]\n",
        "    return errors, wrong_guesses, guesses"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Evaluate performance (test)**"
      ],
      "metadata": {
        "id": "e-QS6HWyYK6w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def test_filename_loader():\n",
        "    \"\"\"\n",
        "    Helper function that loads image file name and corresponding class from 'Human Action Recognition' folder\n",
        "    \"\"\"\n",
        "    test = pd.read_csv('/content/drive/My Drive/Human Action Recognition/Testing_set.csv')\n",
        "\n",
        "    # one-hot encoding not needed for nn.CrossEntropyLoss()(x,y)\n",
        "    # y is the index for the class (0 to 14) and x is the output from the model without sigmoid (1x15 tensor)\n",
        "    classes = {\n",
        "        \"sitting\":0,\n",
        "        \"using_laptop\":1,\n",
        "        \"hugging\":2,\n",
        "        \"sleeping\":3,\n",
        "        \"drinking\":4,\n",
        "        \"clapping\":5,\n",
        "        \"dancing\":6,\n",
        "        \"cycling\":7,\n",
        "        \"calling\":8,\n",
        "        \"laughing\":9,\n",
        "        \"eating\":10,\n",
        "        \"fighting\":11,\n",
        "        \"listening_to_music\":12,\n",
        "        \"running\":13,\n",
        "        \"texting\":14,\n",
        "    }\n",
        "    images = {\n",
        "        0:[],\n",
        "        1:[],\n",
        "        2:[],\n",
        "        3:[],\n",
        "        4:[],\n",
        "        5:[],\n",
        "        6:[],\n",
        "        7:[],\n",
        "        8:[],\n",
        "        9:[],\n",
        "        10:[],\n",
        "        11:[],\n",
        "        12:[],\n",
        "        13:[],\n",
        "        14:[]\n",
        "    }\n",
        "    test_images = []\n",
        "\n",
        "    for _, data in test.iterrows():\n",
        "        if (data[1] in classes.keys()):\n",
        "            img_class = classes[data[1]]\n",
        "            images[img_class].append([img_class, data[0]])\n",
        "    \n",
        "    for imgs in images.values():\n",
        "        test_images += imgs\n",
        "\n",
        "    return test_images\n",
        "\n",
        "def test_data_loader(batch_size=64, shuffle=True, num_workers=0):\n",
        "    \"\"\"\n",
        "    Returns DataLoader objects for train and validation data\n",
        "    \"\"\"\n",
        "    test_images = test_filename_loader()\n",
        "\n",
        "    # normalize the pixel values to between 0 and 1 and crop to same size for DataLoader to work\n",
        "    transform = transforms.Compose([transforms.ToTensor(), transforms.Resize((224, 224)), transforms.FiveCrop(150), transforms.Lambda(lambda crops: torch.stack([crop for crop in crops])), transforms.Resize((224, 224))])\n",
        "    img_dir = '/content/drive/My Drive/Human Action Recognition/test'\n",
        "\n",
        "    test_dataset = HARDataset(data=test_images, img_dir=img_dir, transform=transform)\n",
        "    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)\n",
        "    return test_loader\n",
        "\n",
        "\n",
        "def get_test_acc(net):\n",
        "    if torch.cuda.is_available():\n",
        "        net.cuda()\n",
        "\n",
        "    test_loader = test_data_loader()\n",
        "    softmax = nn.Softmax(dim=1)\n",
        "    total_test_acc = 0.0\n",
        "    num_images = 0\n",
        "    for batch in test_loader:\n",
        "        for image, img_class in zip(batch[\"image\"], batch[\"img_class\"]):\n",
        "            num_images += 1\n",
        "            avg_output = torch.zeros((1,15))\n",
        "            if torch.cuda.is_available():\n",
        "                image.cuda()\n",
        "                img_class.cuda()\n",
        "                avg_output.cuda()\n",
        "            for x in range(5):\n",
        "                avg_output += net(image[x].unsqueeze(0))\n",
        "            avg_output /= 5\n",
        "            pred = softmax(avg_output)\n",
        "            total_test_acc += (np.argmax(pred.detach().cpu(), 1) == np.argmax(img_class.unsqueeze(0).cpu(), 1)).sum().item()\n",
        "    return total_test_acc / num_images"
      ],
      "metadata": {
        "id": "X10tzAW1YKeb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g8nQQGn7TCbw"
      },
      "outputs": [],
      "source": [
        "train_loader, val_loader = data_loader(batch_size=128)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EW3XJWIY5GhT"
      },
      "source": [
        "# **VGG 16**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uhvQ45DviNWU"
      },
      "outputs": [],
      "source": [
        "def get_pretrained_model(model_name):\n",
        "\n",
        "    if model_name == 'vgg16':\n",
        "        model = models.vgg16(pretrained=True)\n",
        "\n",
        "        # Freeze early layers\n",
        "        for param in model.parameters():\n",
        "            param.requires_grad = False\n",
        "        n_inputs = model.classifier[6].in_features\n",
        "\n",
        "        # Add on classifier\n",
        "        model.classifier[6] = nn.Sequential(\n",
        "            nn.Linear(n_inputs, 256), nn.ReLU(), nn.Dropout(0.2),\n",
        "            nn.Linear(256, 15))\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LY6awCmeiy_8",
        "outputId": "bc38ac18-7117-4466-b272-ab26feed047b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1        [128, 64, 224, 224]           1,792\n",
            "              ReLU-2        [128, 64, 224, 224]               0\n",
            "            Conv2d-3        [128, 64, 224, 224]          36,928\n",
            "              ReLU-4        [128, 64, 224, 224]               0\n",
            "         MaxPool2d-5        [128, 64, 112, 112]               0\n",
            "            Conv2d-6       [128, 128, 112, 112]          73,856\n",
            "              ReLU-7       [128, 128, 112, 112]               0\n",
            "            Conv2d-8       [128, 128, 112, 112]         147,584\n",
            "              ReLU-9       [128, 128, 112, 112]               0\n",
            "        MaxPool2d-10         [128, 128, 56, 56]               0\n",
            "           Conv2d-11         [128, 256, 56, 56]         295,168\n",
            "             ReLU-12         [128, 256, 56, 56]               0\n",
            "           Conv2d-13         [128, 256, 56, 56]         590,080\n",
            "             ReLU-14         [128, 256, 56, 56]               0\n",
            "           Conv2d-15         [128, 256, 56, 56]         590,080\n",
            "             ReLU-16         [128, 256, 56, 56]               0\n",
            "        MaxPool2d-17         [128, 256, 28, 28]               0\n",
            "           Conv2d-18         [128, 512, 28, 28]       1,180,160\n",
            "             ReLU-19         [128, 512, 28, 28]               0\n",
            "           Conv2d-20         [128, 512, 28, 28]       2,359,808\n",
            "             ReLU-21         [128, 512, 28, 28]               0\n",
            "           Conv2d-22         [128, 512, 28, 28]       2,359,808\n",
            "             ReLU-23         [128, 512, 28, 28]               0\n",
            "        MaxPool2d-24         [128, 512, 14, 14]               0\n",
            "           Conv2d-25         [128, 512, 14, 14]       2,359,808\n",
            "             ReLU-26         [128, 512, 14, 14]               0\n",
            "           Conv2d-27         [128, 512, 14, 14]       2,359,808\n",
            "             ReLU-28         [128, 512, 14, 14]               0\n",
            "           Conv2d-29         [128, 512, 14, 14]       2,359,808\n",
            "             ReLU-30         [128, 512, 14, 14]               0\n",
            "        MaxPool2d-31           [128, 512, 7, 7]               0\n",
            "AdaptiveAvgPool2d-32           [128, 512, 7, 7]               0\n",
            "           Linear-33                [128, 4096]     102,764,544\n",
            "             ReLU-34                [128, 4096]               0\n",
            "          Dropout-35                [128, 4096]               0\n",
            "           Linear-36                [128, 4096]      16,781,312\n",
            "             ReLU-37                [128, 4096]               0\n",
            "          Dropout-38                [128, 4096]               0\n",
            "           Linear-39                 [128, 256]       1,048,832\n",
            "             ReLU-40                 [128, 256]               0\n",
            "          Dropout-41                 [128, 256]               0\n",
            "           Linear-42                  [128, 15]           3,855\n",
            "================================================================\n",
            "Total params: 135,313,231\n",
            "Trainable params: 1,052,687\n",
            "Non-trainable params: 134,260,544\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 73.50\n",
            "Forward/backward pass size (MB): 28003.76\n",
            "Params size (MB): 516.18\n",
            "Estimated Total Size (MB): 28593.44\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ],
      "source": [
        "from torchsummary import summary\n",
        "model = get_pretrained_model('vgg16')\n",
        "summary(model, input_size=(3, 224, 224), batch_size=128, device='cuda')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hvGuRTGdbtvc",
        "outputId": "846fa517-da4b-415d-87d2-c592997fdb65"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/5 [00:00<?, ?it/s]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 0: Train err: 0.47430555555555554 Val err: 0.3686507936507937 Train loss: 1.468789222874219 Val loss: 1.148471787571907\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r 20%|██        | 1/5 [2:44:57<10:59:48, 9897.19s/it]"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1: Train err: 0.3876984126984127 Val err: 0.34246031746031746 Train loss: 1.1820259803458104 Val loss: 1.0846404165029526\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\r 40%|████      | 2/5 [4:41:37<6:49:38, 8192.87s/it] "
          ]
        }
      ],
      "source": [
        "\n",
        "train(model, train_loader, val_loader, batch_size=128, lr=0.001, num_epochs=5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TnUmo6G33uTe",
        "outputId": "0dbc498b-44f4-4a10-90c1-3f0ddacd9f78"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "error rate {0: 0.40476190476190477, 1: 0.27976190476190477, 2: 0.38095238095238093, 3: 0.25595238095238093, 4: 0.2976190476190476, 5: 0.35714285714285715, 6: 0.20833333333333334, 7: 0.041666666666666664, 8: 0.8273809523809523, 9: 0.35714285714285715, 10: 0.06547619047619048, 11: 0.24404761904761904, 12: 0.5654761904761905, 13: 0.22023809523809523, 14: 0.6309523809523809}\n"
          ]
        }
      ],
      "source": [
        "model.load_state_dict(torch.load(\"/content/drive/My Drive/Human Action Recognition/vgg_best/bs128_lr0.001_epoch5\", map_location=torch.device('cpu')))\n",
        "error_rate, wrong_guess_rate, guesses = performance_per_class(model)\n",
        "print(\"error rate\", error_rate)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "4Erwr2q_4e11",
        "outputId": "f4d83479-783b-4f8f-85a6-a110bc2b0e35"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAFpCAYAAABzpTSxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wc1bXA8d9Rt6olS1ZxkdxtybjKpvcEA8GQ0AkhJI9QElIgJIE0IC+BBAgkIYQaCOWF3gm9d4Llgrux5G7LllzVrH7eHzMyiyzZq92d3ZV0vp/PfrQ7u3vmqKzOzL137hVVxRhjjAGIiXQCxhhjoocVBWOMMXtYUTDGGLOHFQVjjDF7WFEwxhizhxUFY4wxe1hRMKYPEpE1IvKVSOdheh8rCiYqiMjZIvJfEakXkSr3/g9ERCKdmzH9iRUFE3EicgXwN+AmIA/IBS4BDgUSIpha1BCRuEjnYPoHKwomokQkA/hf4Aeq+qSq1qpjvqqeq6pN7uveEZHv+bzvOyLygc/j8SLyuohsF5EVInKmz3MnishSEakVkY0i8jN3e7aI/EdEdrrve19EYtznCkTkKRGpFpHVIvJjn3gzRaRMRGpEZIuI3NLN93aUiGwQkV+JyFa3Sedcn+cTReTPIrLOjXOniAzo9N4rRWQz8K9u9nGhiCxzv7elIjKti9fMFJGP3e+zUkRuE5EE9zkRkb+4Z2c1IrJIRCbu6+dm+jYrCibSDgYSgecCDSAiKcDrwMPAYOBs4HYRKXZfci9wsaqmAROBt9ztVwAbgBycs5NfAeoWhheAz4AhwLHAZSIyy33f34C/qWo6MAp4fB/p5QHZbpzzgbtFZJz73J+AscAUYLT7mqs7vTcLKAQu6uL7PgO4Fvg2kA6cDGzrIoc24HI3j4Pd7+cH7nPHAUe4eWQAZ/rE6O7nZvowKwom0rKBrara2rFBRD5yj2p3i8gRfsQ4CVijqv9S1VZVnQ88BZzhPt8CFItIuqruUNV5PtvzgUJVbVHV99WZDGwGkKOq/6uqzaq6CrgHp9h0vG+0iGSrap2qfrKf/H6rqk2q+i7wInCm21dyEXC5qm5X1Vrgep99ALQD17jv3d1F3O8BN6rqHPfsqlxV13Z+karOVdVP3J/NGuAu4Eif7yUNGA+Iqi5T1cr9/NxMH2ZFwUTaNiDbt81cVQ9R1YHuc/78jRYCB7qFZKeI7ATOxTnSBjgNOBFYKyLvisjB7vabgHLgNRFZJSJX+cQr6BTvVzhnEwAX4BxZLxeROSJy0j5y26Gq9T6P1wIFOGcnycBcn3284m7vUK2qjfuIPQyo2MfzAIjIWLeZbLOI1OAUn2wAVX0LuA34B1AlIneLSLr71u5+bqYPs6JgIu1joAk4ZT+vq8f5J9ohz+f+euBdVR3oc0tV1e8DuEfSp+A0LT2L29zj9l9coaojcZpefioix7rxVneKl6aqJ7rvW6mq57jxbgCedJuwupLZ6bnhwCZgK7AbKPHZR4aqpvq8dn9TGK/Hab7anzuA5cAYt8nrV8CeUV2qequqTgeKcYrdz93tXf7cTN9mRcFElKruBH6H0wdwuoikiUiMiEwBfP+ZLgBOFZFkERmNc7Te4T/AWBE5T0Ti3dsMEZkgIgkicq6IZKhqC1CD0yyDiJwkIqPdppxdOG3v7cCnQK3byTtARGJFZKKIzHDf9y0RyVHVdmCnm0P7Pr7N37l5HI7T1PWE+957gL+IyGA37hCffgt//BP4mYhMdzuMR4tIYRevS3O/7zoRGQ98v+MJ9+d0oIjE4xTeRqB9Xz8307dZUTARp6o3Aj8FfgFscW93AVcCH7kv+wvQ7D73APBvn/fX4nSYno1zFL4Z5wg+0X3JecAat+nkEpymJYAxwBtAHc4Zy+2q+raqtuH8854CrMY5qv8nTkcswPHAEhGpw+l0PrubNn/cXHa4ef0buERVl7vPXYnTfPWJm9sbwLguo3RBVZ8ArsPpYK/FOZrP6uKlPwO+6b7mHuAxn+fS3W07cJq2tuE0q0H3PzfTh4ktsmOMN0TkKOD/VHVopHMxxl92pmCMMWYPKwrGGGP2sOYjY4wxe9iZgjHGmD2sKBhjjNmjV8+8mJ2drUVFRZFOwxhjepW5c+duVdWcrp7r1UWhqKiIsrKySKdhjDG9iojsNUdWB2s+MsYYs4cVBWOMMXtYUTDGGLOHZ0VBRIaJyNvuyk1LROQn7vZr3VWcFri3E33e80sRKRdn5ayeTAxmjDEmBLzsaG4FrlDVeSKShjNv/Ovuc39R1T/7vthdJetsoARnvvk3RGSsOzmZMcaYMPDsTEFVKztWanJnsVyGs9xgd04BHnVXmVqNM3vkTK/yM8YYs7ew9CmISBEwFfivu+mHIrJQRO4TkUx32xCcRUM6bGDfRcQYY0yIeV4URCQVZ73cy1S1BmcVqFE4c9VXAjf3MN5FIlImImXV1dUhzzcaXfnkQq54/LNIp2GM6Qc8LQruak5PAf9W1acBVHWLqrb5rDzV0US0EWfN2Q5D3W1foqp3q2qpqpbm5HR5QV6fsqWmkSfnbeDlxZW0ttnCV8YYb3k5+kiAe4FlqnqLz/Z8n5d9A1js3n8eOFtEEkVkBM6qWJ96lV9v8eTcDbS1Kw3NbSyrrI10OsaYPs7L0UeH4iznt0hEFrjbfgWc466/q8Aa4GIAVV0iIo8DS3FGLl3a30cetbcrj81Zz+jBqZRX1VG2djsHDM3Y/xuNMSZAnhUFVf0AkC6eemkf77kOZ81ZA3yyahvrtjfw17OmcNOrKyhbs4PvHjoi0mkZY/owu6I5ij06Zz3pSXEcPzGP0qJMytZuxxZFMsZ4yYpClNpR38wrizfzjalDSIqPpbQwky01TWzYsTvSqRlj+jArClHqmfkbaW5r5+yZwwGYXpgFQNna7ZFMyxjTx1lRiEKqTgfz5KEZTMhPB2BcXhppiXGUrdkR4eyMMX2ZFYUoNH/9TlZsqeWsGcP3bIuNEaYWZjJ3rRUFY4x3rChEocc+XU9yQiwnTyn40vbSwkxWbKll1+6WCGVmjOnrrChEmbqmVl5YuImTJuWTmvjlEcOlRZmowrx1drZgjPGGFYUo88Jnm2hobtvTwexryrCBxMYIc61fwRjjESsKUebROesZm5vK1GED93ouOSGOkoJ05qyxEUjGGG9YUYgiyypr+Gz9Ts6aMRxn6qi9lRZm8dmGnTS32uR4xpjQs6IQRR6bs56E2BhOndr9MhKlRZk0trSzZNOuMGZmjOkvrChEicaWNp6et4FZE/PITEno9nWlhc6aRDY01RjjBSsKUeLVJZupaWzl7BnD9vm6welJDM9KtovYjDGesKIQJR75dB3Ds5I5eOSg/b62tNAmxzPGeMOKQhRYvbWeT1Zt56wZw4iJ6bqD2df0oky21jWzdltDGLIzxvQnVhSiwONl64mNEU6fPtSv188o6pgcz5qQjDGh5eVynMNE5G0RWSoiS0TkJ+72m0RkuYgsFJFnRGSgu71IRHaLyAL3dqdXuUWTlrZ2nijbwNHjBpObnuTXe0bnpJKeFEeZXa9gjAkxL88UWoErVLUYOAi4VESKgdeBiao6Cfgc+KXPeypUdYp7u8TD3KLGW8ur2FrXtN8OZl8xMcL0wkw7UzDGhJxnRUFVK1V1nnu/FlgGDFHV11S11X3ZJ4B/bSZ91GNz1pObnshR43J69L7SoizKq+rYUd/sUWbGmP4oLH0KIlIETAX+2+mp/wFe9nk8QkTmi8i7InJ4OHKLpMpdu3lnRRVnTB9GXGzPfhV2vYIxxgueFwURSQWeAi5T1Rqf7b/GaWL6t7upEhiuqlOBnwIPi0h6F/EuEpEyESmrrq72On1PPVG2gXaFM0v9bzrqMHnYQOJjxZqQjDEh5WlREJF4nILwb1V92mf7d4CTgHPVHWyvqk2qus29PxeoAMZ2jqmqd6tqqaqW5uT0rMklmrS3O6urHTp6EMMHJff4/UnxsUwcksFcW57TGBNCXo4+EuBeYJmq3uKz/XjgF8DJqtrgsz1HRGLd+yOBMcAqr/KLtA/Kt7Jx527OnrH3FNn+Ki3M5LMNu2hqbQthZsaY/szLM4VDgfOAY3yGmZ4I3AakAa93Gnp6BLBQRBYATwKXqGqfPQx+bM56BibHc1xJbsAxphdm0dzazuKNNjmeMSY04vb/ksCo6gdAV5fnvtTN65/CaWrq87bVNfHa0s2cd1ARiXGxAccpLXI6m8vW7GB6YVao0jPG9GN2RXMEPD1vIy1tytkze97B7Cs7NZER2SnMscnxjDEhYkUhzFSVR+esY9rwgYzNTQs63vTCTOat22GT4xljQsKKQpjNXbuDiur6oDqYfc0oymR7fTOrttaHJJ4xpn+zohBmj3y6ntTEOL42KT8k8Tr6EmweJGNMKFhRCKOaxhZeXLSJ2ZMLSEkMTR//qJwUMpPjbdEdY0xIWFEIo+cXbKKxpb1Hk9/tj4gwvTDLprswxoSEFYUwenTOOibkpzNpaEZI45YWZbJqaz1b65pCGtcY0/9YUQiTxRt3sXhjDWfPGIZzsXfo2OR4xphQsaIQJo/NWU9iXAxfnzIk5LEPGJpBQlyMFQVjTNCsKITB7uY2nl2wkRMPyCcjOT7k8RPjYpk0JIM5NgLJGBMkKwph8NKiSmobWzkrhB3MnU0vymTxxl00ttjkeMaYwFlRCIPH5qxnRHYKB47wbn6iGYVZtLQpCzfY5HjGmMBZUfBYeVUdn67ZzlkedDD7mu52NlsTkjEmGFYUPPZ42XriYoRTp4W+g9lXZkoCo3JSrLPZGBMUKwoeam5t56m5Gzh2wmAGpyV5vr8ZRc5FbO3tNjmeMSYwVhQ89MayLWyrb+bsmaGZ/G5/phdmsmt3C+XVdWHZnzGm77Gi4KFH56wnPyOJI8aEZy3pGUUdk+NZE5IxJjBertE8TETeFpGlIrJERH7ibs8SkddFZKX7NdPdLiJyq4iUi8hCEZnmVW7hsGFHA++vrOaM0mHExnjXweyrcFAy2akJlK21zmZjTGC8PFNoBa5Q1WLgIOBSESkGrgLeVNUxwJvuY4ATgDHu7SLgDg9z89zjZRsAOLN0aNj26UyOl2lnCsaYgHlWFFS1UlXnufdrgWXAEOAU4AH3ZQ8AX3fvnwI8qI5PgIEiEppFB8KsrV15omw9h4/JYWhmclj3PaMoi3XbG6iqbQzrfo0xfUNY+hREpAiYCvwXyFXVSvepzUCue38IsN7nbRvcbZ1jXSQiZSJSVl1d7VnOwXhvZTWVuxpDOkW2vzquV5hrZwvGmAB4XhREJBV4CrhMVWt8n1NnYeEejZ9U1btVtVRVS3NywtOB21OPfrqOQSkJfGVC7v5fHGIlBRkkxsUwx4qCMSYAPSoKIhIjIuk9eH08TkH4t6o+7W7e0tEs5H6tcrdvBHwPrYe623qVqtpG3lxWxWnTh5IQF/7BXQlxMUwZNpC51tlsjAnAfv9ricjDIpIuIinAYmCpiPzcj/cJcC+wTFVv8XnqeeB89/75wHM+27/tjkI6CNjl08zUazw9byOt7cqZpeFvOupQWpTJkk01NDS3RiwHY0zv5M+hbLHb7PN14GVgBHCeH+871H3dMSKywL2dCPwJ+KqIrAS+4j4GeAlYBZQD9wA/6NF3EgVUlcfmrGdmURajB6dGLI/Swixa25UF63dGLAdjTO/kz+rx8W4z0NeB21S1RUT22w+gqh8A3Q3QP7aL1ytwqR/5RK13Pq9m9dZ6fnj06IjmMW14JiJOZ/Mho7Ijmosxpnfx50zhLmANkAK8JyKFQM0+39HPtLUrd7xTwUUPljFk4ABOPCCyI2kzkuMZOziNMpsczxjTQ/s9U1DVW4FbfTatFZGjvUupd1m/vYGfPr6AOWt2cMLEPK7/xgEMSIiNdFpML8rkhQWbaGvXsF1RbYzp/fzpaM4VkXtF5GX3cTFfdBT3W6rK42XrOf6v77G8spZbzpzM7edOIzMlIdKpATCjKJPaplY+31Ib6VSMMb2IP30K9wP/An7tPv4ceAxnZFG/tK2uiV89s4hXl2xh5ogsbjlzctivXN6f0kJ3cry1O5iQ7/coYtMPrdvWwH8WbSIrOYGctMQ9t0EpiREZVm0iy5+ikK2qj4vILwFUtVVE+u1CwG8t38IvnlxEze4WfnXieC44bGRUNs8MzRzA4LREytZs57yDCsO238aWNp6Zv5ETJ+aTkRwftv2awN35XgUP/3ddl88NTI4nJ9UpEtmpXxSMnNREst2vOWmJZKUkROXnwPScP0WhXkQG4V553HENgadZRaGG5lb+8OIyHv7vOsbnpfHQBTOj+ghcRJhRlBX2yfFufGUF9324mtveKufv35zKtOGZYd2/6bnyqjqmDh/Ibd+cRnVt057b1rov7lfXNbFg/U6qa5vY3bL3MWGMQFbKF0UjO9U56ygpyODocTmkJdkBQm/hT1H4Kc6FZaNE5EMgBzjd06yizPx1O7j8sQWs3d7AxUeM5KfHjSUxLvKdyfszvTCTFxdVUrlrN/kZAzzf39y1O/jXR6v5anEuyyprOPPOj/n5rHFcePhIYuwoMmqtqq7j2PG5DBk4gCED9/93Ut/UuqdQbHW/di4k5Vtqqa5roqVNSYiN4fAx2ZxwQD5fnZBrZ5BRzp/RR/NE5EhgHM51BytUtcXzzKJAS1s7f3+rnH+8XU5eehKPXHgQB40cFOm0/FZa5Byll63ZwezJ3haFptY2rnxqIfnpSdxy5mTaFa56aiF/fHk5H6/axs1nTGZQaqKnOZie29nQzNa65h5dbJmSGEdKYhxF2Sn7fF17uzJ33Q5eXrSZVxZX8ubyKuJihINHDeKEifkcV5JLtv1NRB1/Rh+dAQxQ1SU4F7A91tsXwPFHRXUdp93xEbe+uZJTphTw8mWH96qCAFCcn05yQixzw3C9wt/fLKe8qo7rTz2AtKR4MgbEc/u50/j9KSV8VL6NE299n09WbfM8D9MzFe7SraMG7/sffCBiYpwmzKtnF/PhVcfw3KWH8r3DR7J+ewO/emYRM697g7Pu+pj7P1zN5l021Xu08Kf56Leq+oSIHIZzJfKfcRbAOdDTzCJEVXnok7Vc/9IykuJjuf3caRG/GC1QcbHO5Hher8S2eOMu7ni3gtOmDeWocYP3bBcRzju4iGmFmfzw4fl8855PuOwrY7n06NHWKRklKqrqARiV4+20LCLC5GEDmTxsIFceP47lm2t5eVElLy/ezLUvLOXaF5YydfhATpiYxwkT8xmWFV2j+foTf4pCR6/S14B7VPVFEfmDhzlFzJaaRn7+5ELe+7yaI8fmcNPpkxicnhTptIJSWpjJbW+XU9fUSmqiP7/unmlpa+cXTy4kMzmB3540ocvXlBRk8MKPDuPXzyziltc/55NV2/jr2VMYnBbZn217u/LeymrSB8T32w7xiuo6EuJiwjqkWkSYkJ/OhPx0fnrcOMqr6nhlsVMgrn9pOde/tJyJQ9I5YWI+x0/M87xgmS/z57/ERhG5C/gqcIOIJBKmxXnC6cWFlfz62UU0trTx+69P5FsHDseZ6LV3Ky3Kol1hwbqdHDYm9PMg3f3eKpZW1nDnt6YxMLn7C/dSE+P461lTOHRUNlc/v5gT//Y+fzlrCoePCf+aGM2t7Tz/2SbuereClVV1xAhcdcJ4Ljx8ZJ/4nfdEeVUdI7NTInrmNnpwKj88Zgw/PGYM67Y18MoSp0Dc9OoKbnp1BWNzUzl+Yj4nTMxjfF5av/sdhZs/ReFM4Hjgz6q6010DYb9TZ/cWu3a3cO3zS3hm/kYmD83glrOm9Kkjk6nDBxIjULZ2e8iLQnlVLX97YyUnHpDH8RP338QmIpw5YxhThg/k0n/P49v3fcoPjhrF5V8ZS1ys98cZdU2tPPrpOu79YDWVuxoZn5fGzWdM5q3lVVz/0nI+W7+LG0+fRIoHZ1TRqqK6jpKCjEinscfwQclcdMQoLjpiFJW7dvPK4s28vHgzf39rJbe+uZKiQcmccEA+lxwxykYxecSfv/584EVVbRKRo4BJwIOeZhUmH1ds44rHF7CltomfHDuGHx4zmvgw/HMKp7SkeMblpYf8eoW2duUXTy4kOTGW3508sUfvHZubxvM/PIxrn1/CP96u4NPV2/nb2VMp8GM4ZCCqa5u4/6PVPPTxWmoaWzloZBbXn3oAR43NQUQ4ddoQJr2XwQ2vLOfzLbXcdd50RvahA4PuNLW2sW57AydPLoh0Kl3KzxjAdw8dwXcPHUF1bROvLd3MK4s3c/d7q1i3rYF/nNvnx7tEhD//AZ8C2kRkNHA3zupoD3ualccaW9q47sWlfPOfn5AYH8uTlxzM5V8d2+cKQocZRZnMX7eD1rb2kMV84KM1zFu3k2tmF5OT1vNhhQMSYrnh9En89awpLN1Uw4m3vs+by7aELD+Atdvq+fUzizj0hre4/Z0KDhmVzTM/OIRHLzqYo8cN3tMMISJcfOQoHrrgQLbVN3PKbR/y+tLQ5hKN1m5roF1hVATX/vBXTloi5x5YyEMXHMhlx47hxUWVfLBya6TT6pP8+S/YrqqtwKnA31X15zhnD73WZ+t38s8PVvPNmcN58ceHMbWPdzJOL8ykvrmN5ZtDMzneum0N3PTqCo4el8PXpwwJKtbXpw7hhR8dRkHGAC54oIw//Gcpza3BFa9FG3Zx6b/ncfSf3+GJsg2cOnUIb/z0SO48b/o+f9eHjs7mhR8dxoicFC58sIybX1tBW3uPlhDvVcqr3OGoveys6MIjRlI4KJmrn18c9N+K2Zs/RaFFRM4Bvg38x92238Y8EblPRKpEZLHPtsd8VmFbIyIL3O1FIrLb57k7A/lm/HXgyEG8fvkRXPeNA0hO6Pvtx6VF7uR4a4IfmqqqXPX0QmJjhOu+cUBIOv1G5qTy9A8O4dsHF/LPD1Zzxl0fs357Q4/zen9lNef+8xNm3/YB731ezUVHjOKDK4/mT6dN8vsf35CBA3j84oM5s3Qof3+rnP+5fw47G5oD+baiXoVbFEbmhP4aBS8lxcdy7ewSVlXXc9+HqyOdTp/jT1H4LnAwcJ2qrhaREcBDfrzvfpwO6j1U9SxVnaKqU3CapZ72ebqi4zlVvcS/9AM3enCa17uIGkMGDqAgIykki+48Omc9H1Vs41cnTghpH0BSfCz/e8pE7jh3Gquq6zjx1vd5edH+l+hubXNGEp309w84795PWbmljqtOGM+HvzyGq04YH9CQ4qT4WG44bRLXf+MAPqrYyuzbPmDppr63rlRFdR1DBg7olQdGR48fzFcm5HLrmyup3LU70un0KfstCqq6FLgSmOc+Xq2qN/jxvveALg9NxTm8PBN4pEfZmoBNdyfHc1Y9DUzlrt1c/+IyDh45iHNmDgthdl844YB8XvzR4YzMTuH7/57H1c8tprGLCdgaW9p46OM1HHPzu/z4kfnsbmnjhtMO4P0rj+aSI0eRHuQEbCLCNw8czmMXH0xLq3LqHR/yzPwNQcWMNuXVdb2iP6E718wupq1due7FZZFOpU/xZ5qL2cAC4BX38RQReT7I/R4ObFHVlT7bRojIfBF5V0QO30c+F4lImYiUVVdXB5lG/1FamMnmmkY27gzsqEpV+c0zi2lpb+dPp4Wm2ag7wwcl88Qlh/C9w0bw4MdrOfX2j1jlTsews6GZW99cyaF/eovfPreErJQE7vzWdN64/EjOmjE85BMVThueyQs/OozJQwdy+WOfce3zS2gJYYd9pLS3KxVV9YzqZU1HvoZlJfODo0bzn4WVfFhunc6h4s9547XATOAdAFVdICIjg9zvOXz5LKESGK6q20RkOvCsiJSo6l7n7Kp6N84oKEpLS/tuL2CIdUyON3ftjoCuXn1uwSbeXF7Fb742gcJB3v8jSYiL4TcnFXPwqEFc8cRnzP77Bxw/MZ+XF1fS0NzG0eNyuOTIUcwckeX5xUw5aYn83/cO5E8vL+feD1azdFMNt507NeJXZAdjc00ju1vael0nc2cXHzmSp+Zt4Jrnl/DSjw+3RYFCwK+OZlXtvH5CwIdKIhKHM5LpsY5tqtqkqtvc+3OBCmBsoPswexufl05qYlxA1ytsrWvidy8sYerwgXz30BEeZNe9Yyfk8tKPD6e4IJ1nF2xkVkker1x2OP/67kwOHDkobFe3xsfG8NuTivnb2VNYtHEXJ936QVgmGvRKx0R4PZkdNRolxcdyzexiyqvquP8j63QOBX/OFJaIyDeBWBEZA/wY+CiIfX4FWK6qexpoRSQH2K6qbe5ZyBhgVRD7MJ3ExghThw9kTgAjkK55fgn1TW3ceNqkiEyHUOCOCGpqbScpPrLrWJwyZQhjc9O45P/mcvbdH3P17JJeOSVKbx2O2pVjJ+TylQmD+esbKzl58hDyMqLnDG7X7ha21TX1qosh/TlT+BFQAjThNPnUAJft700i8gjwMTBORDaIyAXuU2ezdwfzEcBCd4jqk8Alqurt1J79UGlhFiu21FLT6P9yGK8u2cyLCyv58bGjGZMbuRFbIhLxgtBhQn46z196GIeNzua3zy7mZ08s7LIzPJpVVNeRnhRHdmr381X1JlefVEJru3LdS9HT6Vzb2MLpd3zEKbd92Kv+PvwZfdSgqr9W1RmqWure3+/k56p6jqrmq2q8qg5V1Xvd7d9R1Ts7vfYpVS1xh6NOU9UXAv+WTHdKizJRhfnrdvr1+l0NLfzm2cUU56dz8ZGjPM6ud8lIjufe82fwk2PH8NS8DZx2x0c9vrYikiqq6hk1OLXXneF0Z/igZL5/5Che+GwTH1VEvtO5rV358SPzWVlVR21Ta6+6+tqf0Udvi8hbnW/hSM6E1pRhA4mNEb8vYvv9i0vZXt/MjadP6rNTgAQjJka4/Ktjuff8UtZtb2D2bR/w/sreMSKuorqO0b2oScMf3z9qFMOyBnDNc5EfIXbDK8t5e0U118wuJi0pjleXbI5oPj3hzyf9Zzizov4c+C3O8NQyL5My3khJjKM437/J8d79vJon527g4iNGMnFI9MyiGY2OnZDLCz88jNy0JM6/71Nuf6c8qOtBvFbT2EJVbVOvvkahK0nxsVxzUgkrq+q4/8M1EcvjibL13H8Ct5MAACAASURBVP3eKr59cCHfPXQEx4wfzBvLtoR07jEv+dN8NNfn9qGq/hQ4yvvUjBemF2Yyf/2OfR5J1TW18qunFzEqJ4UfHzsmjNn1XkXZKTxz6SF8bVIBN76ygu//3zzqm1ojnVaXKvpQJ3NnXynO5Zjxg/nrG5+zpSb8S3yWrdnOr55ZxGGjs7n6pGIAZpXksaOhhTkhnqnYK/40H2X53LJFZBZgh469VGlRJo0t7fuctuHGV5azaddubjx9ctR07vYGyQlx3Hr2FH7ztQm8smQz93+0JtIpdami2lmCs7cPR+3ONbOLaWlXrg9zp/OGHQ1c/NBchmYm849vTtuzRsiRY3NIjIvpNU1I/jQfzcVpLpqLM5roCuCCfb7DRK3SQndyvG7G2H+6ejsPfryW7xxSxPTCvj17rBdEhO8dPpKROSksWO9fh364lVfVER8rDMv0Zv2KSCsclMIlR47iuQWb+LhiW1j2Wd/UyvceKKO5rZ17vl36pQWAUhLjOHxMDq8t2RzVzYod/Gk+GqGqI92vY1T1OFX9IBzJmdDLy0hiaOaALjubG1vauPKphQzLGsDPZ42LQHZ9R0lBRtROoldRXUfRoJSwrHYXKT84ahRDMwdwzfOLPe90bm9XLn9sAZ9vqeUf35zW5RnYrJJcNu1qZNHGztcBRx9/mo9O7eJ2rIgMDkeCJvRKCzMpW7v35Hh/ef1zVm+t50+nTuqVM2dGk5KCdDbu3M2O+uibdruiuq5P9if4SoqP5eqTivl8Sx0PeNyMd/PrK3ht6RZ+e1IxR4ztes3xr0zIJTZGekUTkj+HChcA/wTOdW/34Mya+qGInOdhbsYjpUVZVNc2sX77F5PjfbZ+J/e8v4pzZg7j0NGhXcu5PyopSAdgWWV0nS20tLWzbltDn+1P8PXV4lyOGpfDX99YSZVHnc7PLdjIP96u4JyZw/jOIUXdvi4zJYGZRVm8uiT6V/TzpyjEARNU9TRVPQ0oBhQ4EKc4mF6mY3K8jikvmlvbufKphQxOS+KXJ06IZGp9RnG+UxSWRFkT0tpt9bS2K6MG997ZUf0lIlw7u4Tm1nZPOp0XrN/Jz59cyMwRWfzu5In7vRBwVkku5VV1e+adilb+FIVhqupb3qrcbdsB/+dLMFFj7OA00pLi9nQ23/5OOcs313LdNyYGvQ6BcQxKTSQvPYklm6KrDbm8yhl51NebjzoUZadw8ZEjeXbBJv67KnSdzpW7dnPhg2Xkpidy57em+zU763EleQBR34TkT1F4R0T+IyLni8j5wHPuthQgOodXmH2KiRGmF2Yyd+12lm+u4ba3yjllSgHHTsiNdGp9SklBetSdKXQcpfamCdqC9YOjRjNk4ACuDtGVzrub27jwwTIamlq59/wZZKX4N39UwcABTB6aEfVNSP4UhUuBfwFT3NuDwKWqWq+qR3uZnPFOaWEmn2+p47JHF5AxIJ5rZpdEOqU+p6QgnYrqOnY3R89kaBVVdeRnJJGa2H8GEgxIiOXq2cWs2FLLgx+vDSqWqvKzJz5jyaYabj1nKmN7OEnkcSV5fLZ+Z1QvIerPkFR1J6y73L09qb1hsK3Zp9Ii53qF5Ztr+d0pJX4f7Rj/FRdk0K6wfHP0nC30h5FHXTmuOJcjx+bw19c/p6o28E7nW98s58VFlVx1/PiAzqxnuU1Ir0Xx2ULfHahs9mny0IEkxcdwXHEuXzsgP9Lp9EkdI5CWRskIJFWlorp3L8EZKBHh2pNLaGpt508vLQ8oxosLK/nLG59z6rQhXHREYItPjh6cyqiclKjuV7Ci0E8NSIjlPz86nFvPmdpnpk+ONkMzB5CeFBc1/QpVtU3UNbX2i+GoXRmRncKFR4zg6fkb+XR1z5ZrWbxxF1c8sYBpwwfyx1ODW6N8Vkke/129PSqvYYF9FAURedP9ekP40jHhNHpwqs1t5CERoTiKOpv70mprgbr06I5O58V+z1paVdPIhQ+WkZWcwF3nlZIYF9xnZlZJHm3typvLq4KK45V9nSnki8ghwMkiMlVEpvne9hdYRO4TkSoRWeyz7VoR2SgiC9zbiT7P/VJEykVkhTvpnjG9XklBBssra6Ji2uSOkUd9bcrsnkhOiOO3J01g+eZaHvpk/53OjS1tXPTQXHY2tHDP+aXkpCUGncOkoRnkZyRFbRPSvoYgXI2zfsJQ4JZOzylwzH5i3w/chjNayddfVPXPvhtEpBhnmc4SoAB4Q0TGqmr0DNswJgAlBek0tbazamt9j0eqhFpFVR2piXEMDsE/tt5sVkkeh4/J5pbXPuekSQXd/qNXVa56aiEL1u/kzm9No6QgNJNDiwizSvJ45NN1NDS3Rt2UMt2eKbijjE4AblTVozvd9lcQUNX3AH8b7k4BHlXVJlVdDZQDM/18rzFRq+MfSTRcxFZR3beW4AyUiPC7k0tobG3jjy93f6XzHe9W8OyCTfzsuLEcPzG0gzGOK8mlqbWdd1dE30p9/gxJ/b2InCwif3ZvJwW5zx+KyEK3ealjbuYhwHqf12xwtxnTq43KSSEhLiYqZkwtr6rrlyOPujIyJ5ULDx/J0/M2djlj8GtLNnPTqyuYPbmAS48eHfL9zyzKIjM5PiqbkPyZJfWPwE+Ape7tJyJyfYD7uwMYhXMRXCVwc08DiMhFIlImImXV1dFXZY3xFRcbw/i8tIh3Ntc1tbK5prFfdzJ39sNjRlOQkcRvn1vypT6fZZU1XPbYAg4YksFNp0/y5MwqLjaGYyfk8ubyKppbI9/f5MufIalfA76qqvep6n3A8UBAZwuqukVV21S1HWe21Y4moo3AMJ+XDnW3dRXjblUtVdXSnJyup6k1Jpp0THcRyWs+V7mdzP11OGpXkhPi+M1JxSyrrOHf/10HwNa6Jr73QBlpSXHc8+1ST0fnzSrJo7axlU9COCdTKPh7ncJAn/sB97aIiG/D3DeAjpFJzwNni0iiiIwAxgCfBrofY6JJcUEGu3a3sHFn5KY2sOGoXTthotPp/OfXVrBp526+/39z2VrXxD3fLiU3PcnTfR8+JpvkhNioa0Lypyj8EZgvIveLyAM4y3Jet783icgjOMt3jhORDSJyAXCjiCwSkYXA0cDlAKq6BHgcp3nqFZy5lWzkkekTOq5sjmQTUkV1HXExQuGg5IjlEI06rnRubGnja7e+z5w1O/jzGZOZNHTg/t8cpKT4WI4al8PrS7fQ3h49Mwf509H8CHAQ8DTwFHCwqj7mx/vOUdV8VY1X1aGqeq+qnqeqB6jqJFU9WVUrfV5/naqOUtVxqvpyMN+UMdFkQl46MRLholBVz/BBycT34SU4AzUqJ5ULDhvJjoYWfnzMaGZPLgjbvmeV5FFV28T8KFrP268Bsu4/7+c9zsWYPmlAQiwjc1JZGsFhqRXVdYy2pqNuXXHcWI4Ym81BIwaFdb9Hjx9MfKyzTOf0wsz9vyEM7LDBmDAoKUiP2LDU1rZ21myr79dXMu9PfGwMh4zKJiYmvNdwpCfFc/CobF5dsjmiAxF8WVEwJgyK89PZtKsxIpOgrdveQEubWidzlJpVksvabQ2s2FIb6VSA/RQFEYkVkcDmmTXG7PHFlc3hP1uoqO5YgtMuXItGXy3ORQReXRwdayzssyi4I4BWiMjwMOVjTJ/0xQik8Pcr7BmOas1HUWlwWhLThmdGzdBUf5qPMoElIvKmiDzfcfM6MWP6ksyUBAoykiJ0plDH4LRE0pPiw75v45/jS/JYWlnD+u0NkU7Fr9FHv/U8C2P6geKCjIicKfTXJTh7k1kleVz30jJeXbKZ7x0e2KpuoeLPdQrvAmuAePf+HGCex3kZ0+eUFKSzams9Dc2tYdunqlJRVWfTW0S54YOSGZ+XFhVNSP5MiHch8CRwl7tpCPCsl0kZ0xcVF6SjCss3h2+USXVdEzWNrdbJ3AvMKsmjbO0OqmubIpqHP30KlwKHAjUAqroSGOxlUsb0RZGY7qKiyh15ZGcKUW9WSR6q8MayyI5C8qcoNKnqnsHVIhKHs/KaMaYHhgwcQMaA+LBe2bxnCU7rU4h6E/LTGJY1IOJNSP4UhXdF5FfAABH5KvAE8IK3aRnT94jInmm0w6W8qo7khFjyM7yd8dMET0Q4viSPj8q3UdvYErE8/CkKVwHVwCLgYuAl4DdeJmVMX1VSkM7yzbW0tIVnYZWOkUf9fQnO3mJWSR7Nbe28HcFlOv0ZfdQOPAD8Hvgd8IBGyyQdxvQyJQUZNLe2s8q9ythrq6rrrZO5F5k2PJPs1EReXRy5JiR/Rh99DagAbgVuA8pF5ASvEzOmLyoO45XNDc2tbNy52/oTepGYGOGrxbm8s6KKxpbILCnjT/PRzcDRqnqUqh6JszjOX7xNy5i+aWR2ColxMWHpV+g4G7FrFHqXWSW51De38WH51ojs35+iUKuq5T6PVwH7HWgtIveJSJWILPbZdpOILBeRhSLyjIgMdLcXichuEVng3u7s8XdiTC8QFxvD+Pz0sJwp7Bl5ZEWhVzlkVDZpiXERG4XUbVEQkVNF5FSgTEReEpHviMj5OCOP5vgR+37g+E7bXgcmquok4HPglz7PVajqFPd2SY++C2N6kY61FbzumquoqiNGsCU4e5mEuBiOHj+YN5ZV0RqmAQm+9nWmMNu9JQFbgCOBo3BGIg3YX2BVfQ/Y3mnba6racY3/J8DQnqdsTO9WUpBOTWMrG3bs9nQ/FdX1FA5KITEu1tP9mNA7fmIe2+ubKVu7I+z77nZCPFX9rsf7/h/Ad63nESIyH+fK6d+o6vse79+YiPBdW2FYlndH8eVVdTbyqJc6cmwOCXExvLpkMweNDO8Sof6MPhohIreIyNOhmjpbRH4NtAL/djdVAsNVdSrwU+BhEUnv5r0XiUiZiJRVV0duLK8xgRqfl0aM4OmVzW3tyuqt9TbyqJdKSYzjiDHZvLZkS9iX6fRn6uxngXtx+hKCbuASke8AJwHHdlzvoKpNQJN7f66IVABjgbLO71fVu4G7AUpLS+16CdPrJMXHMion1dMRSBt2NNDc1m5FoRc7riSPN5ZVsXhjDQcMzQjbfv0pCo2qemsodiYixwO/AI5U1Qaf7TnAdlVtE5GRwBicUU7G9EklBel8smr7/l8YIFttrff7yoRcYgReXbI5rEXBnyGpfxORa0TkYBGZ1nHb35tE5BHgY2CciGwQkQtwLn5LA17vNPT0CGChiCzAmab7ElX17hNjTISVFGSwuaaRbXXeTJP8xUR41qfQW2WlJDBzRFbYh6b6c6ZwAHAecAxfNB+p+7hbqnpOF5vv7ea1TwFP+ZGLMX2C7zTaR4zNCXn8iqp6slMTGJicEPLYJnxmleTxuxeWsqq6jpFhagr050zhDGCkqh6pqke7t30WBGPMvnVMd7G00pt+BVuCs2+YVZIHwKtLwrfGgj9FYTEw0OtEjOlPBiYnMGTgAE86m1WV8uo660/oAwoGDmDS0IywNiH5UxQGAstF5NVQDUk1xjhnC15Md7G9vpmdDS12ptBHzCrJY8H6nWze1RiW/fnTp3CN51kY0w+VFKTzxrIt1De1kpLoz0fRPxXuRHjWydw3zCrJ5aZXV/Da0s18++Aiz/e3379EVX3X8yyM6YdKCjJQheWba5hemBWyuB3DUW121L5h9OA0Ruak8OqS8BQFf65orhWRGvfWKCJtIhK+9QSN6aN8RyCFUkV1HUnxMRRk7HeKMtNLzCrJ45NV29nZ0Oz5vvxZeS1NVdNVNR1nIrzTgNs9z8yYPi4/I4nM5HiWelAURmanEhNjS3D2FceX5NHWrry5rMrzffnT0byHOp4FZnmUjzH9hohQUpDhyZmCjTzqWyYNzSA/Iykso5D226fgrqnQIQYoBcLTDW5MH1dckM79H66hpa2d+NgeHaN1qbGljQ07dnP6tGEhyM5ECxHhuOJcHitbT0NzK8kJoRuY0Jk/f4WzfW6zcFZdO8WzjIzpR0oK0mlua9/TORysVdX1qMKowTbyqK+ZVZJHY0s7733u7ezQ/ow+8npdBWP6Ld/O5gn5Xc4W3yNfzHlkzUd9zcwRWQxMjufVJVs4fmK+Z/vptiiIyNX7eJ+q6u89yMeYfmVEdioD4mNZsmkXp08PfiHC8qo6RGBEtp0p9DVxsTEcOz6X15duDllzY1f2FbW+ixvABcCVnmRjTD8TGyOMz08LWWdzRXUdwzKTSYq3JTj7olkludQ0tvLJqm2e7aPboqCqN3fccBa1GQB8F3gUGOlZRsb0MyUF6SzbVBOSFbYqquvtSuY+7IixOQyIj/V0FNI+zz9EJEtE/gAsxGlqmqaqV6qq94NljeknSgoyqG1qZf323UHFaW9XVtnsqH1aUnwsR43L4bUlW2hv92bhyW6LgojcBMzBGW10gKpeq6o7PMnCmH6sOL+jszm4yfE27txNU2u7TW/Rx80qyaOqton563d6En9fZwpXAAXAb4BNPlNd1Po7zYWI3CciVSKy2Gdbloi8LiIr3a+Z7nYRkVtFpFxEFvqzupsxfcG4vDRiYyTofoXyaluCsz84evxg4mKE1zxqQtpXn0KMqg7wnebCvaW5U174437g+E7brgLeVNUxwJvuY4ATcNZmHgNcBNzRk2/EmN4qKT6W0TmpQZ8pVFTZcNT+IGNAPKdMGUJakjcXsHl3WRygqu+JSFGnzacAR7n3HwDewRnNdArwoDq9bZ+IyEARyVfVSi9zNCYalBSk80H51qBiVFTXk5WSQFaKLcHZ19185mTPYnsz0HXfcn3+0W8Gct37Q4D1Pq/b4G4zps8rLkinqraJ6tqmgGNUVNXZyCMTtEgUhT3cs4IedaGLyEUiUiYiZdXV3l7ubUy4lBRkAMGt2WzrMptQiERR2CIi+QDu147hrRsB31m8hrrbvkRV71bVUlUtzcnJ8TxZY8Ih2BFIO+qb2VbfbEXBBC0SReF54Hz3/vnAcz7bv+2OQjoI2GX9Caa/yEiOZ2jmgIBHIHXMeWTDUU2wPO1oFpFHcDqVs0VkA856z38CHheRC4C1wJnuy18CTgTKgQacq6eN6TdKCtIDXnDHJsIzoeL16KNzunnq2C5eq8ClXuZjTDQrKcjg1SVbqGtqJTWxZx/Niup6EuJiGJJpS3Ca4ES0o9kY84WOabSXB9DZXFFVx8jsFGJtCU4TJCsKxkSJjhFIgfQrlNsSnCZErCgYEyVy0xMZlJLQ4xFIjS1trN/eYP0JJiSsKBgTJUSE4oL0Hp8prN3WQLtiF66ZkLCiYEwUKS5I5/MttTS3tvv9no71nW04qgkFKwrGRJGSggxa2pSVVbV+v6djOOrIbCsKJnhWFIyJIh0jkHpyvUJFdR1DBg5gQIItwWmCZ0XBmCgyYlAKyQmxPepXqLCRRyaErCgYE0ViYoQJ+f5f2dzerlRU1TPaRh6ZELGiYEyUKc5PZ2lljV9r8FbWNLK7pY1Rg23kkQkNKwrGRJmSgnTqmlpZt71hv6+11dZMqFlRMCbK9OTKZhuOakLNioIxUWZsXipxMcLSyv1f2VxRXUfGgHgG2RKcJkSsKBgTZRLjYhk9ONWvMwVntbUURGwiPBMaVhSMiUIlBRl+FoV6608wIWVFwZgoVFyQTnVtE1W1jd2+ZtfuFqprm6w/wYSUFQVjolDHlc37Oluw1daMF8JeFERknIgs8LnViMhlInKtiGz02X5iuHMzJloU+zHdxZ7hqHamYELI0+U4u6KqK4ApACISC2wEnsFZk/kvqvrncOdkTLRJT4pneFbyvotCdT0JsTEMsyU4TQhFuvnoWKBCVddGOA9jok5JQfo+F9wpr6qjKDuZuNhIf4xNXxLpv6azgUd8Hv9QRBaKyH0iktnVG0TkIhEpE5Gy6urq8GRpTASUFKSzZlsDtY0tXT6/qrrO+hNMyEWsKIhIAnAy8IS76Q5gFE7TUiVwc1fvU9W7VbVUVUtzcnLCkqsxkdBxZfOyyr3XVmhubWetLcFpPBDJM4UTgHmqugVAVbeoapuqtgP3ADMjmJsxEVe8ZwTS3k1Ia7fV09auNhzVhFwki8I5+DQdiUi+z3PfABaHPSNjosjgtESyUxO6HJZqw1GNV8I++ghARFKArwIX+2y+UUSmAAqs6fScMf2OiFDczZXNFdX1AIzMsSmzTWhFpCioaj0wqNO28yKRizHRrKQgnX++v4rm1nYS4r44sa+oqiM/I4mUxIh8hE0fFunRR8aYfSgpSKelTfl8y5c7m8ur66w/wXjCioIxUaxjBJLvRWyqSkWVDUc13rCiYEwUK8xKJiUh9ksjkLbUNFHf3MYo608wHrCiYEwUi4kRJuSnf6mzudzmPDIesqJgTJQrKUhnWWUN7e0KfDEcdbQ1HxkPWFEwJsqVFGRQ39zG2u0NgFMU0hLjyElLjHBmpi+yomBMlOt8ZXNFdR0jB6faEpzGE1YUjIlyY3PTiI+VPf0K5VV11nRkPGNFwZgolxAXw+jBaSzZVENtYwtbapoYNdhGHhlvWFEwphcoKUhn6aZde6a3sGsUjFesKBjTC5QUpLO1rpmPK7YBVhSMd6woGNMLdFzZ/Pxnm4iLEQoHJUc4I9NXWVEwpheYkJ8GwLLKGgoHJRNvS3Aaj9hfljG9QFpSPEXu2YE1HRkvWVEwppfoaEKy2VGNl6woGNNLdFzEZmcKxksRW6FDRNYAtUAb0KqqpSKSBTwGFOGsvnamqu6IVI7GRJMDR2QRIzBpaEakUzF9WKTPFI5W1SmqWuo+vgp4U1XHAG+6j40xQGlRFvN/exxjctMinYrpwyJdFDo7BXjAvf8A8PUI5mJM1MlIjo90CqaPi2RRUOA1EZkrIhe523JVtdK9vxnI7fwmEblIRMpEpKy6ujpcuRpjTL8QyVW/D1PVjSIyGHhdRJb7PqmqKiLa+U2qejdwN0BpaelezxtjjAlcxM4UVHWj+7UKeAaYCWwRkXwA92tVpPIzxpj+KCJFQURSRCSt4z5wHLAYeB44333Z+cBzkcjPGGP6q0g1H+UCz7iLhMQBD6vqKyIyB3hcRC4A1gJnRig/Y4zplyJSFFR1FTC5i+3bgGPDn5ExxhiIviGpxhhjIkhUe+8AHhGpxmlmClQ2sDVE6XgZ0+J6F7O3xe1Nufa2uL0p12DjFqpqTldP9OqiECwRKfO5mjpqY1pc72L2tri9KdfeFrc35eplXGs+MsYYs4cVBWOMMXv096Jwdy+JaXG9i9nb4vamXHtb3N6Uq2dx+3WfgjHGmC/r72cKxhhjfFhRMMYYs4cVBWOMMXtYUQgxEUnvmOzPGGN6m37V0Swit3axeRdQpqpBzcgqIjOA+4A0QICdwP+o6twgYk7rYvMuYK2qtgYY89RuYi5ypzEPiBe5unFfwFmQqXPcMuAuVW0MIGZWF5trVbUlgBR94/60i827gLmquiCIuF7lu4juf7Z/cOcii3hML+O6sR8AfqKqO93HmcDNqvo/gcb0glef3b3208+Kwt3AeOAJd9NpwGpgELBKVS8LIvZC4FJVfd99fBhwu6pOCiLmJ8A0YCFOoZkILAEygO+r6msBxHwROBh42910FDAXGAH8r6o+FC25unH/BuQAj7ibzgJqcP5BpKvqeQHEXAMMA3a4uQ7EWelvC3BhoIVcRB4GSoEX3E0n4fw8ioAnVPXGAON6le+NQBvwsLvpbCDZjX2Yqs6OhphexnVjz1fVqfvb1sOYtXRfxK5wJwXtaUxPPrt7UdV+cwM+AWJ9HscBHwOxwNIgY8/vYtu8IGM+DZT4PC4GngRGAgsCjPkqzrKnHY9z3W1ZwOJoytWNM6e7bcCSAGPeA8zyeXwccBdwEPDfIHJ9D0j1eZwKvAsMCObvy8N89/r77NiGc/QZFTG9jOu+/zMg0+dxVghi/h64GKflIB24CLgB56DmnQBjevLZ7Xzrb30KmTgf1A4pQJaqtgFNQcZ+V0TuEpGjRORIEbkdeEdEpnXTtOKPsaq6pOOBqi4FxmsARxk+hqnqFp/HVe627UAwzRFe5AqQKiLDOx649zt+h80BxjxIVV/teKDOWczBqvoJkBhwpjCYL/8dteB8iHcT3N+XV/nGisjMjgduE2is+zDQJj8vYnoZF+Bm4GMR+b2I/AH4CAjorM7Hyap6l6rWqmqNOssIz1LVx3D+DwXCq8/ul0RyjeZIuBFYICLv4JyGHwFc767+9kaQsTvWh7im0/apOKeRxwQQc4mI3AE86j4+C1gqIokE/kfwjoj8hy83ob3j/gx2BhjTq1wBrgA+EJEKnN/ZCOAHbr4PBBizUkSu7JTrFhGJBdqDyPXfwH9FpKN/ajbwsJvr0iDiepXv94D7RCQV52dbA3zPzfePURTTy7io6oMiUsYXn9FT3YOaYDSIyJk4Z8sApwMd/V+Bttl79dn9kn7VpwB71n7uOOKYo6qbIpnPvojIAOAHwGHupg+B23H+uJJVtS6AmILzx3SoT8ynNMg/BC9y9YmdiNMXBLBCA+hc7hQvG6d4++b6O5w23+GqWh5E7BnAIR1xVbUsmFzdmJ7l68bPAFDVXcHE8TpmqOOKSLqq1nTTkY97BB5o7JHA33D6ABSn6fpyYCMwXVU/CCCmJ5/dvfbTD4vCEKAQn7MkVX0vBHEzcD64R7ib3sXp/Anph6I/EpFDcDprfX9nD0YsoX1wj95z+XKu6yKXUffcYnsae/9s/zeaYnoVV0T+o6onichqvnz0Lk5oHRlo7N6sXzUfiUhHR88SvjjtVpwOwmDdByzmi3WlzwP+BXQ1jMwvInIocC17F7GA/1jdYW034LR/C198ANIDjelVrm7ch4BRwAKc0Sfg/M4CLgoiMhb4GXv/gwmkic837o9wDgy24OQqbq4Bj0Bz43qSL/Ac7pBZgu9T8zKmJ3FV9ST364hQxPMlIjnAhez9Owt4mKtXn9299tOfzhREZAUwSVVD+cfaEXuBqk7Z37YexlyOhyl9nQAAF81JREFUc8o5ly/+IaLBjckuB2ar6rJAY3QTN+S5unGXAcWhPEUWkc+AO9k714CvKXHjlgMHBvs9dxHXq3wXq+rEINPzPKaXcd3Yh+KMkKsXkW/hDK3+azBneCLyEfA+e//Ongoipief3c761ZkCsAqIJ7RHMB12i8hhHW2F7h/a7iBj7lLVl4NP7Uu2ePRH5UWu4Jx95QGVIYzZqqp3hDBeh/U4R7Oh5lW+H4nIAaq6KMpjehkX4A5gsohMxhnY8E/gIeDIIGImq+qVoUjOh1ef3S/pb2cKT+GMEnoTn8Kgqj8OQezJOE0aGe6mHcD5qrowiJh/whl29zRfzndeEDH/hvNP9tlOMZ8ONKYbN+S5unHfBqYAn3aKe3IQMa/FGc73TKeYAXcsunHvBcYBL3aKe0uQca/Fm3yXAqNxLuBs4ovmiGAuuAx5TC/jurHnqeo0Ebka2Kiq93ZsCyLmH4CPVPWlYPPzienJZ3ev/fSzonB+V9tVNdChjb6xR6jqahFJd2PWdGwLIubbXWzWYNqSReRf3cQM6pJ+L3J143Z5tKaq7wYRs6vfSdAdiyLSeThyR+DfBRnXq3wLu9quqmujKaaXcd3Y7wKvAN/FGShSBXymqgcEEbMW5zqoJpwh2UG3/3v12d1rP/2pKHipqyMLEZmrqtMjlZMxXfFiKKZXwzu9HDbqs4884Js4Q9TfF+cCyaOidYSb1/pFURCRx1X1TOl6Ui2CPF0eD5TgXBj3c5+n0oGfq2pJADG/par/J11PsBZQc4SI/EJVbxSRv9P1zyCgJjQvcnXjfqCqh8nec8gEfMQlIseo6lvS9cRiAZ+Gi8hfVfUy6XryvoCbujzMt/NQTPly2J6fgXgR08u4XhGR8aq6XLqZxSCQ5lSvPrvd6S8dzT9xv57kQexxbtyBOFewdqjFGZIWiBT3ayin4O7ooAr6YqpOvMgVVT3M/RrKuEcCb/Hl39OeXeL0hwSiYyKyPwf4/u54kq8XQzG9iOllXF+dDjwScAaj1KlqRvfv6tZPceY5urmL5wKd2cCrz26X+sWZQgcRuaHziICutgUY+2BV/TjYOOHi9n2oqtaGKF5W51P5YPtUfOJMw7maV4EPVHV+sDGNI9QXc4rIm6p67P62RUvcLvYjwCk4801dFcrYwRKRM1T1if1tC3o//awodNXuvzBEIxg6Lms/COef18fA5RrEhHDiwfoPIlKKc1FdyNZ9cON+CJygqjXu4wk400UHNbbcHRFyBl8cFX/djfuHIGJeD9yoX54//wpV/U2A8bpsliTIETLdNcl1+P/2zjzKsqo647+vG9ItyuBACCgyg0GgXYgDcQgQW0WCggMiKEmLqBjHICJGYhaKLBSXmkYUEFoRWmVYojIIKmArikAjczAqaqJMamRWoeHLH/vcqldVr7ur3r2vbhV3/9aq1fXue2/f01X1zj5nn72/3UBWU1XMeRM9hYGDhLskzSekrC8hJJ2rMM86wLdsP20lb23F7iTuW0s6u9hotBJ/JfNXrSypfnQifCTpYEKXZwtF34OKtQlFxCZYCnwG2Ls83pfoAfCcGjbn07//wwJJu3qw/g+nAG/z2L4PS6hZdQt8FPimpD2IkNqpwP41bVJsLHDROyqpr9cAAzsFwnl9oHpg+4+SXgYM5BQYTlgSGg7J9WEvYBs3U8z5FuDdwEZEwVY1ed8DHDcD7Y4w7sxmDtETo66+VmOV+JJ2B14GPHncQnEd6ivETqATToGYsC8g1BR7t4T3NpG9UFjLY5tcnCbp0JW+enLsADzPIe2NQoX0+0QoZdAinocrhwBg+weSav9h2T5P0prARcRktrft/65rF7iVcI7Vh3QeISpWh7mS5lWToULMb2AJ6iotUtJmwG09DuwxhA7SoHZrpbJOgsaKOW1/Gvi0pHfYXlx7ZEO2O47eM5sVwK+IEFIddqK5SvxbifOElxOOseJeQkWgUTrhFByidHdLWjE+r1nSlzxA964+XCDp/YS8sYlt+flVKt2Azqfq/1BVyY70f5A06Af5e5JOIHYx1TgvrbIlppod0ScjYl3gF8DbJTWRGXE3Icv97XKfhcAV1YppQPunA9/tyftexOAy3L2cyahCKsQK8UzgWYMYW0n4cIQaGWPV7+wBQkq+sWJO24slbUc0WZrfc71WemexOxRhRNuL6troQ2OV+LavBa4tZyi/6X1O0jZEoWxjdMIp9DAmPVTSGkBTdQSVEN5bxl3fl/gADpI6N4z+D033fRifEVHrbKIPXytfFZfWNWj7mBJGrA4pP+yeJjY1WMP2SOMf2w9K+qsa9pr+WVZUv7PlwDeaNFwK+HYhnML5wO7AD6ghYFjsNi6M2GN7M+AdTHQ4A1fNA08i+ok0VolPLGSOsH0GgKRDgAOJn3VjdOKgWdLhwAeItogPVJeJzl0n2j68rbGtDs2i/g/DokysTyMmgZ/2TrwzibKbWWz7G+XxK4B3Np0hM5Mph+4LiPa0CyRtAJxme2FNu40LI/bYvhY4mQjJjjQtcr2q+WFU4m8InEiEUjcgUlUPcY1eJX3v0wWnUCHp6GE6gKa3zSspgLkb+LXtgc4Byof0o8BGtneXtC3R2vHkQcdZ7I6Xzm5Ek74cAJ9AhKSqzmtvcQ3xPQ1PPnxL4DTiUBTgN8AbbP+ipt31gcOY+LdVV0KkX9ZU1Vz+Ix5A7VXSFbafLWk5sCsR9/6vullCks4kHGyTwoiV7R/brpMQMm1I+hfgcMJ57Wu7qUSZ0Xt0wSkMo8qwzz36bpttv7qGzcsJGd/riIlrO6IXxLrAwY5evVO1eQGRbfRvZSW3BrGqG1jnpdgdlnT2zcA/unQXk7QFcF6dSUbDkw+fW857HgfQ1ApO0kXAV4meCm8F/gn4nWvW10j6GPG7Wlou7Uukf94OPN92v6K51dk8ntiVv7aM9z7i72sgfR6NVomvTcPCiD332A/YikiSaEp4svGFh6TvEIfO7wQ2JnY3y2y/d1Cb/ejKmUK/KsNeb1i3WQlED9Zq27yo2jbXtHkrcKDtGwHKqv5I4H1E3v6UnQLwJNtnlJAatldIenh1b5oEw5LOvtdj203eQqw+6zAsCeKfKZR4T2nY/hMdyp3vKuGH70m6sgG7LxqX4369RhVDXz+gzbcTOkIbEEkBT6VeemfTVeL92J5oirUbY5tv1ZkXPkbzC4/jbJ9Tvr9L0s6EA26UTjgF228u336WKHi5R9IRxCr8ww3d5k+2H5G0QlEtfCfhzeuwdeUQAGzfVHY9t0ha1ftWxf2SnkhxipKeSzM9AC6R9HEals4GrpJ0PnAGMebXAFdWueUeTP/nKklfpXkJ4gXEavtkSXOImpCvuBT01eCh8u9tpQ7kVqCvQNwUmSvp2bavAFD0l55bnhs0TfkzxMS6m+0jJd1NLF4GysCqE4OfAq8BNm/4rKrxhYftc0pd0Va2lxDZiXUXnhPohFPo4YNllfx8YhVwLOEomognXiVpPeAkIoRyH1HVXIcbS23CV8rj1xIZDfMYnSimyr8SGSdbKKqQ1yd2OXWpfoY79Vyru9qCiKHfwWjDk98RCQN7Mrj+zzpEwsGLe67V0T4KAyEZchJwUjloXAp8UtJZRIbTz1dpYOV8RNED/BBgMTH+QQoXx/Mm4JQS7hJREPamkt129IA2n1N2Gj+BkcLAOhlYwAR9oorq/OMQ11AOINJH1yMWck3R+MKjhKh3IopDlxA6TacBz6s31HH36cKZQoVK6bqko4HrbS9VA+Xsfe6zKbCOazTYKXYeQ1RiP79cugw4ntiOrzVozLqcI2xDTAQ/tT2og0l6kDQX2IOoe9iUEMo7HXgB8FHbWw9o94vAuzwqy/EE4NhB4/R97K8LI/U8dW39mKjVuLI4h/WBi+p+xiR9mDi4X0r83e5LpKheTZyv7VLD9qVEoeiVNNfIqfHeB5KuIVLHr65+nmpIpmfMfTrmFM4lqmEXEqGjPwFX2F6wyjeu2uYqdUeaOMRuEklrEbuFTWwfJGkrQurg3AHtDUU6u8f+fCIX++mMzbyp8+Fq3Gaxewuh0XPy+KwQSf/pwYvNJixcmljMKHSlJmD7yBo29yd2tDsSBYGvJnbotUTbJF07/nOq0gO933NTtN14+ugw6Mnsqs59Hgv8qGmn0LXw0T7AS4lV1l0l77euFEU/idyKWuETjWrIjzVaL81zCRHe2rk8/i1RdTuQU2BI0tk9fAm4GXgJcci+P6NSwjPJJkRh1SEeK7T3CdtvHNQhFOZIerztPxa7T6CZz+79Pd/PJzScav0cbJ9e0lH/gVjR79VQbP0BSfsAZ5XHr2b0ALvWynZ1k7+kH9neeVWv6fOeJf3GVXPhcYZCjWA9SQcBbyTClY3SKadg+wF64sYl57lW3rPtXSfzOkkLbX97iuZ74/PziQOxugeMW9h+raTXQfxMVOPU2vYJJWxyj+1P1hxbP7a0/RpJr7D9RUlLCf2nmWYTYLPKIcBIPL2J0OQngB+VXH2Iv4Oj6hq1PWZBI+lYoHZlt+2bCafbJPsTKsTHE5Pt5cDrS4j17Q3fazzzV/+SCfQusuYTQpl1C0/XJ5ziPUT499+BF9W0OYFOOYWWOQaYklPok+P/qbIK67vtnyQPlg9SlX20BTUF0Upu/uuAYTiF6rzjLkVx4O1E7vdMswlDWtHbPlXSVYzuOl9p+6a6dvuwFvCUIditTTlIXlndxA+Gffspv8E+u/expC9Tf5wLS23KyDwi6RNEYWNjpFOYPqa8Gh93XlFJ+tb9nX2IaFK+saTTicyFf65pE+AySccRRVYjYYkGzlROLGGYI4isqcdRzyn22vxgj80jatqEIa3oIdKRib4HjaGxFc1ziZXowOcJw0DT3IpyiGzFgAsPjUr/b66J0v+XNTC2sffr0kFzm2iAZhiSLmH0g1BJ+h7rmpLUpU7huYSjutz27+vYKzYvKd9W460qOJsoDGyElRyGV87adQ/Fyz22ZXRFf/GQVvSNIGmTnocriNz6xvX56yDpD7afKOnd9FEDtd2Euu3qxjClQ/0Sjn2YSEuvuB04fPwOYpL21iVqEoYp/T96v3QK08OATmE+0VhnU0Z3CB4kO2RYWVI9E62gb2P1gSbalWUz9Riest2S5w0Rj30WowqhexJZaINW8c5qJP01Y7Ow/qfF4YxB0k1E3PwCxnZeAwaWpO93nw0YLbC7wvadPc9tZ/uGKdq7wTW7DrZFho+mj18N8J5ziHaZV1OzExQrbyReMeiKvso6qibarxMf3D0JnZpBqeyOdzTVtSnj0rRG0jJgx1JshqT/AM4bbJizF0kvJ/4uNiIKtzYhso+evqr3TTOfBb5LSM/3SolXi5BagosAJavp44Qsu4DFkg61fRbAVB1CYbmkZ9luQo5kWsmdQkNobEu/iruJIrmBKiWHsdooH4AJUh91Y/9lot2jZ6JdmxCue2FNu+MLt0bSPGvY/Cmwg0c7r80DrrO9TZ2xzjYUktG7Ad8pRZ27Aq+3fWDLQ5uApM/aPnhItq8lDnHvLI/XJ34mdWofbga2BH5NnLHV6tc9neROoTkOJHL/q9j6LsTKZjNJR3psq87J8kNJ29setPVmP4Yl9bEB0Z+i4kFqtKLsYYchpHmeSnRvq5r37AV8oabN2chDtv8gaY6kObYvkfSptgfVj2E5hMKccQu3PxCJHXV4Sc33t0Y6heZYA/hb23fASIzyVGKyXUYUTE2KnqyQNYBFpVL2LzSz2qgUUfcATnL0Vv5IDXsVw5poG0/ztH2UQkL8BeXSIts/qTnO2chdCt2jZcDpku5kbEFbV/iWpAuJFrUQFdm1FH89ru3vbCLDRw0h6Sbb2/Y8FnCj7W0HyF7YZFXP1/mD0xCkPnps78joRLusiYlW0gGEPPCYNM8Bd15JD0Um4c/EYmN/ok/H6X3qYx71lPBvpTH2fdtfW9XrH82kU2gIRXORpzI6eb2KEPA6FDh3spXPw0ahffRS4qzjZ0XqY3sP0LBnuphNaZ7J7EPSMR7XsKjfta6QTqEhys7gVYzK2F4GnO38ASczDPWXoQaaaUs62+iXLq4hqI/OFtIpJEnSSXorhYke4BVrA5d1tm4lnUIzaEjN4JMkGQ6TrRTuTXToAukUGkJDagafJEm7DKJGMJupm4ubjDKsZvBJkrTLwNLys5GsU2iOYTWDT5KkXToVTkmn0BxDaQafJEkynaRTaAjbi9oeQ5IkQ6FT4aM8aK7Jo6gJSJJ0kiKdMp57bT9UPT+MvgUzldwp1Kc6XL6q1VEkSTIoVwMbE018BKwH3C7pDuAg28tX9eZHG7lTGAKS5gCPs31P22NJkmTVSDoJOMv2heXxiwl1giXAp23XVRCeVWRKakNIWippnSIydgNwk6RD2x5XkiSr5bmVQwAoOmA7274cmNfesNohnUJzbFt2BnsRsrubAW9od0hJkkyC2yQdJmmT8vU+4A5Jc4FH2h7cdJNOoTnWlLQm4RS+UR1SJUky49kPeApRY3QOoXa8HzAX2KfFcbVCHjQ3x+eAXwLXActKT4S72x1SkiSrw/bvgXes5OmfT+dYZgJ50NwQkj7U89DELmyu7SNaGlKSJJNA0tbAe4FN6Vko295tZe95NJM7hea4r+f7+cDujKarJkkyczmT2Ol/ntF2tZ0ldwpDQtI84ELbu7Q9liRJVo6k5baf2fY4Zgp50Dw81iIOr5Ikmdl8U9LbJG0o6QnVV9uDaovcKTSEpOsZlbmYC6wPHGn7uPZGlSTJ6pD0yz6XbXvzaR/MDCCdQkOUbKOKFUR/hRVtjSdJkmQQ0ikkSdJJJO1m++LSSncCXe2FktlHSZJ0lb8HLgb27PNcZ3uh5E4hSZIkGSF3CkmSdJqSPv4qJhavHdnWmNoknUKSJF3n64QkzXJ6+qt3lQwfJUnSaSTdYHu7tscxU8jitSRJus4PJW3f9iBmCrlTSJKk00i6CdiSUDn+C9GS07Z3aHVgLZFOIUmSTjOu8HQE27+e7rHMBDJ8lCRJpymT/8bAbuX7B+jw3Jg7hSRJOk3phbITsI3trSVtBJxp+3ktD60VOusNkyRJCnsDLwfuB7B9K7B2qyNqkXQKSZJ0nQcdIRMDSHpsy+NplXQKSZJ0nTMknQCsJ+kg4DtEF7ZOkmcKSZJ0HkkLgRcT6agX2v52y0NqjXQKSZJ0GknH2D5sdde6QoaPkiTpOgv7XNt92kcxQ0hBvCRJOomkg4G3AZtLuq7nqbWBy9oZVftk+ChJkk4iaV3g8cDRwPt7nrrX9v+1M6r2SaeQJEmnkbQF8Bvbf5G0C7ADcKrtu9odWTvkmUKSJF3nbOBhSVsCJxKSF0vbHVJ7pFNIkqTrPGJ7BfBKYLHtQ4ENWx5Ta6RTSJKk6zwk6XXAAcC55dqaLY6nVdIpJEnSdRYBOwNH2f6lpM2AL7U8ptbIg+YkSZJkhKxTSJKkk0g6w/Y+kq6niOH1kp3XkiRJOoSkDW3flp3XxpJOIUmSJBkhw0dJknQSSffSJ2xEKKXa9jrTPKQZQe4UkiRJkhEyJTVJkiQZIZ1CkiRJMkI6hSSZJJL+RtJXJP1C0nJJ50vaWtINbY8tSZoiD5qTZBJIEvA14Iu29y3XFgAbtDqwJGmY3CkkyeTYFXjI9ueqC7avBf63eixpU0nfl3R1+fq7cn1DScskXSPpBkkvkDRX0hfK4+slvWf6/0tJMpHcKSTJ5NgOWL6a19wJLLT9Z0lbAV8GdgL2I5rBHyVpLrAW8Azgyba3A5C03vCGniSTJ51CkjTHmsBxkp4BPAxsXa5fCZwiaU3gHNvXSLqFaAO5GDgPuKiVESfJODJ8lCST40bgmat5zXuAO4AFxA7hrwBsLwNeCPwW+IKkA2z/sbzuUuCtwOeHM+wkmRrpFJJkclwMzJP05uqCpB2ILl0V6wK32X4EeAMwt7xuE+AO2ycRk/+Okp4EzLF9NvBBYMfp+W8kyarJ8FGSTALblrQ38ClJhwF/Bn4FvLvnZccDZ0s6APgWcH+5vgtwqKSHgPuIZi5PBpZIqhZmhw/9P5EkkyBlLpIkSZIRMnyUJEmSjJBOIUmSJBkhnUKSJEkyQjqFJEmSZIR0CkmSJMkI6RSSJEmSEdIpJEmSJCOkU0iSJElG+H8cdtYN8yio6QAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "x = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])\n",
        "xtick = [\"sitting\", \"using_laptop\", \"hugging\", \"sleeping\", \"drinking\", \"clapping\", \"dancing\", \"cycling\",\n",
        "  \"calling\", \"laughing\", \"eating\", \"fighting\", \"listening_to_music\", \"running\", \"texting\"]\n",
        "\n",
        "plt.xticks(x, xtick, rotation = 90)\n",
        "plt.plot(x, list(error_rate.values()))\n",
        "plt.title(\"Error rates per class\")\n",
        "plt.xlabel(\"Class\")\n",
        "plt.ylabel(\"Error rate\")\n",
        "plt.show()\n",
        "plt.xticks(x, xtick,rotation = 90)\n",
        "plt.plot(x, list(wrong_guess_rate.values()))\n",
        "plt.title(\"Wrong guess rate per class\")\n",
        "plt.xlabel(\"Class\")\n",
        "plt.ylabel(\"Wrong guess rate\")\n",
        "plt.show()\n",
        "plt.xticks(x, xtick, rotation=90)\n",
        "plt.plot(x, list(guesses.values()))\n",
        "plt.title(\"Guesses per class\")\n",
        "plt.xlabel(\"Class\")\n",
        "plt.ylabel(\"Number of guesses\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.load_state_dict(torch.load(\"/content/drive/My Drive/Human Action Recognition/vgg_best/bs128_lr0.001_epoch1\", map_location=torch.device('cpu')))\n",
        "test_accuracy = get_test_acc(model)\n",
        "print(f'Test accuracy: {test_accuracy}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "44556Nqpaql9",
        "outputId": "55169303-3565-437d-a3cc-c3b215353298"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test accuracy: 0.33653846153846156\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}