age_gender_without_torch_snippets.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "#Original code = \"https://github.com/PacktPublishing/Modern-Computer-Vision-with-PyTorch/blob/master/Chapter05/Implementing_VGG16_for_image_classification.ipynb\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GO820-swkq7r"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np, cv2, pandas as pd, glob, time\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import optim\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torchvision\n",
        "from torchvision import transforms, models, datasets\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bZVyS3nCku1o"
      },
      "outputs": [],
      "source": [
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "\n",
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)\n",
        "\n",
        "def getFile_from_drive( file_id, name ):\n",
        "  downloaded = drive.CreateFile({'id': file_id})\n",
        "  downloaded.GetContentFile(name)\n",
        "\n",
        "getFile_from_drive('1Z1RqRo0_JiavaZw2yzZG6WETdZQ8qX86', 'fairface-img-margin025-trainval.zip')\n",
        "getFile_from_drive('1k5vvyREmHDW5TSM9QgB04Bvc8C8_7dl-', 'fairface-label-train.csv')\n",
        "getFile_from_drive('1_rtz1M1zhvS0d5vVoXUamnohB6cJ02iJ', 'fairface-label-val.csv')\n",
        "\n",
        "!unzip -qq fairface-img-margin025-trainval.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        },
        "id": "NK77ld3gkyvk",
        "outputId": "fb5a9f83-6097-4773-e541-41c2a9c08492"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>file</th>\n",
              "      <th>age</th>\n",
              "      <th>gender</th>\n",
              "      <th>race</th>\n",
              "      <th>service_test</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>train/1.jpg</td>\n",
              "      <td>59</td>\n",
              "      <td>Male</td>\n",
              "      <td>East Asian</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>train/2.jpg</td>\n",
              "      <td>39</td>\n",
              "      <td>Female</td>\n",
              "      <td>Indian</td>\n",
              "      <td>False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>train/3.jpg</td>\n",
              "      <td>11</td>\n",
              "      <td>Female</td>\n",
              "      <td>Black</td>\n",
              "      <td>False</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>train/4.jpg</td>\n",
              "      <td>26</td>\n",
              "      <td>Female</td>\n",
              "      <td>Indian</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>train/5.jpg</td>\n",
              "      <td>26</td>\n",
              "      <td>Female</td>\n",
              "      <td>Indian</td>\n",
              "      <td>True</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "          file  age  gender        race  service_test\n",
              "0  train/1.jpg   59    Male  East Asian          True\n",
              "1  train/2.jpg   39  Female      Indian         False\n",
              "2  train/3.jpg   11  Female       Black         False\n",
              "3  train/4.jpg   26  Female      Indian          True\n",
              "4  train/5.jpg   26  Female      Indian          True"
            ]
          },
          "execution_count": 3,
          "metadata": {
            "tags": []
          },
          "output_type": "execute_result"
        }
      ],
      "source": [
        "trn_df = pd.read_csv('fairface-label-train.csv')\n",
        "val_df = pd.read_csv('fairface-label-val.csv')\n",
        "trn_df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XVOL0emTljbq"
      },
      "outputs": [],
      "source": [
        "from torch.utils.data import Dataset, DataLoader\n",
        "import cv2\n",
        "IMAGE_SIZE = 224\n",
        "class GenderAgeClass(Dataset):\n",
        "    def __init__(self, df, tfms=None):\n",
        "        self.df = df\n",
        "        self.normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], \n",
        "                                              std=[0.229, 0.224, 0.225])\n",
        "    def __len__(self): return len(self.df)\n",
        "    def __getitem__(self, ix):\n",
        "        f = self.df.iloc[ix].squeeze()\n",
        "        file = f.file\n",
        "        gen = f.gender == 'Female'\n",
        "        age = f.age\n",
        "        im = cv2.imread(file)\n",
        "        im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n",
        "        return im, age, gen\n",
        "\n",
        "    def preprocess_image(self, im):\n",
        "        im = cv2.resize(im, (IMAGE_SIZE, IMAGE_SIZE))\n",
        "        im = torch.tensor(im).permute(2,0,1)\n",
        "        im = self.normalize(im/255.)\n",
        "        return im[None]\n",
        "\n",
        "    def collate_fn(self, batch):\n",
        "        'preprocess images, ages and genders'\n",
        "        ims, ages, genders = [], [], []\n",
        "        for im, age, gender in batch:\n",
        "            im = self.preprocess_image(im)\n",
        "            ims.append(im)\n",
        "\n",
        "            ages.append(float(int(age)/80))\n",
        "            genders.append(float(gender))\n",
        "\n",
        "        ages, genders = [torch.tensor(x).to(device).float() for x in [ages, genders]]\n",
        "        ims = torch.cat(ims).to(device)\n",
        "\n",
        "        return ims, ages, genders"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cfQ7WlW1mO8c"
      },
      "outputs": [],
      "source": [
        "trn = GenderAgeClass(trn_df)\n",
        "val = GenderAgeClass(val_df)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eJEiuBhlnPd-",
        "outputId": "fd1dd131-c563-4d02-af65-819886175782"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([32, 3, 224, 224]) torch.Size([32]) torch.Size([32])\n"
          ]
        }
      ],
      "source": [
        "device='cuda'\n",
        "train_loader = DataLoader(trn, batch_size=32, shuffle=True, drop_last=True, collate_fn=trn.collate_fn)\n",
        "test_loader = DataLoader(val, batch_size=32, collate_fn=val.collate_fn)\n",
        "a,b,c, = next(iter(train_loader))\n",
        "print(a.shape, b.shape, c.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84,
          "referenced_widgets": [
            "a247b4c6ac9d44ab8e4c82ccfa9d8b05",
            "e0597664297e4074aafb1abc74462c54",
            "7a01294a511e42b394dd62f2af3f3014",
            "c029002323f34a74a873b4175906a3ea",
            "e6a7f4bb399f42969d624bc55fcb81e4",
            "169be448255e45e4b69f47740b1fc4e9",
            "2e780ce258ee4277b0d7e3fc99fef48e",
            "da9aacf457e948a9a406b0e5f7028bb0"
          ]
        },
        "id": "nvj3Nb6_ngim",
        "outputId": "e4eab945-a346-4b24-9251-24abeecb96f6"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "a247b4c6ac9d44ab8e4c82ccfa9d8b05",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=0.0, max=553433881.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "def get_model():\n",
        "    model = models.vgg16(pretrained = True)\n",
        "    # Freeze parameters so we don't backprop through them\n",
        "    for param in model.parameters():\n",
        "        param.requires_grad = False\n",
        "    model.avgpool = nn.Sequential(\n",
        "        nn.Conv2d(512,512, kernel_size=3),\n",
        "        nn.MaxPool2d(2),\n",
        "        nn.ReLU(),\n",
        "        nn.Flatten()\n",
        "    )\n",
        "    class ageGenderClassifier(nn.Module):\n",
        "        def __init__(self):\n",
        "            super(ageGenderClassifier, self).__init__()\n",
        "            self.intermediate = nn.Sequential(\n",
        "                nn.Linear(2048,512),\n",
        "                nn.ReLU(),\n",
        "                nn.Dropout(0.4),\n",
        "                nn.Linear(512,128),\n",
        "                nn.ReLU(),\n",
        "                nn.Dropout(0.4),\n",
        "                nn.Linear(128,64),\n",
        "                nn.ReLU(),\n",
        "            )\n",
        "            self.age_classifier = nn.Sequential(\n",
        "                nn.Linear(64, 1),\n",
        "                nn.Sigmoid()\n",
        "            )\n",
        "            self.gender_classifier = nn.Sequential(\n",
        "                nn.Linear(64, 1),\n",
        "                nn.Sigmoid()\n",
        "            )\n",
        "        def forward(self, x):\n",
        "            x = self.intermediate(x)\n",
        "            age = self.age_classifier(x)\n",
        "            gender = self.gender_classifier(x)\n",
        "            return gender, age\n",
        "        \n",
        "    model.classifier = ageGenderClassifier()\n",
        "    \n",
        "    gender_criterion = nn.BCELoss()\n",
        "    age_criterion = nn.L1Loss()\n",
        "    loss_functions = gender_criterion, age_criterion\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr= 1e-4)\n",
        "    \n",
        "    return model.to(device), loss_functions, optimizer\n",
        "\n",
        "model, loss_functions, optimizer = get_model()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XceUr1tWoJEL",
        "outputId": "777581fd-661e-4b5a-f024-3e35d5d29a22"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: torchsummary in /usr/local/lib/python3.6/dist-packages (1.5.1)\n",
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1         [-1, 64, 224, 224]           1,792\n",
            "              ReLU-2         [-1, 64, 224, 224]               0\n",
            "            Conv2d-3         [-1, 64, 224, 224]          36,928\n",
            "              ReLU-4         [-1, 64, 224, 224]               0\n",
            "         MaxPool2d-5         [-1, 64, 112, 112]               0\n",
            "            Conv2d-6        [-1, 128, 112, 112]          73,856\n",
            "              ReLU-7        [-1, 128, 112, 112]               0\n",
            "            Conv2d-8        [-1, 128, 112, 112]         147,584\n",
            "              ReLU-9        [-1, 128, 112, 112]               0\n",
            "        MaxPool2d-10          [-1, 128, 56, 56]               0\n",
            "           Conv2d-11          [-1, 256, 56, 56]         295,168\n",
            "             ReLU-12          [-1, 256, 56, 56]               0\n",
            "           Conv2d-13          [-1, 256, 56, 56]         590,080\n",
            "             ReLU-14          [-1, 256, 56, 56]               0\n",
            "           Conv2d-15          [-1, 256, 56, 56]         590,080\n",
            "             ReLU-16          [-1, 256, 56, 56]               0\n",
            "        MaxPool2d-17          [-1, 256, 28, 28]               0\n",
            "           Conv2d-18          [-1, 512, 28, 28]       1,180,160\n",
            "             ReLU-19          [-1, 512, 28, 28]               0\n",
            "           Conv2d-20          [-1, 512, 28, 28]       2,359,808\n",
            "             ReLU-21          [-1, 512, 28, 28]               0\n",
            "           Conv2d-22          [-1, 512, 28, 28]       2,359,808\n",
            "             ReLU-23          [-1, 512, 28, 28]               0\n",
            "        MaxPool2d-24          [-1, 512, 14, 14]               0\n",
            "           Conv2d-25          [-1, 512, 14, 14]       2,359,808\n",
            "             ReLU-26          [-1, 512, 14, 14]               0\n",
            "           Conv2d-27          [-1, 512, 14, 14]       2,359,808\n",
            "             ReLU-28          [-1, 512, 14, 14]               0\n",
            "           Conv2d-29          [-1, 512, 14, 14]       2,359,808\n",
            "             ReLU-30          [-1, 512, 14, 14]               0\n",
            "        MaxPool2d-31            [-1, 512, 7, 7]               0\n",
            "           Conv2d-32            [-1, 512, 5, 5]       2,359,808\n",
            "        MaxPool2d-33            [-1, 512, 2, 2]               0\n",
            "             ReLU-34            [-1, 512, 2, 2]               0\n",
            "          Flatten-35                 [-1, 2048]               0\n",
            "           Linear-36                  [-1, 512]       1,049,088\n",
            "             ReLU-37                  [-1, 512]               0\n",
            "          Dropout-38                  [-1, 512]               0\n",
            "           Linear-39                  [-1, 128]          65,664\n",
            "             ReLU-40                  [-1, 128]               0\n",
            "          Dropout-41                  [-1, 128]               0\n",
            "           Linear-42                   [-1, 64]           8,256\n",
            "             ReLU-43                   [-1, 64]               0\n",
            "           Linear-44                    [-1, 1]              65\n",
            "          Sigmoid-45                    [-1, 1]               0\n",
            "           Linear-46                    [-1, 1]              65\n",
            "          Sigmoid-47                    [-1, 1]               0\n",
            "ageGenderClassifier-48         [[-1, 1], [-1, 1]]               0\n",
            "================================================================\n",
            "Total params: 18,197,634\n",
            "Trainable params: 3,482,946\n",
            "Non-trainable params: 14,714,688\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.57\n",
            "Forward/backward pass size (MB): 218.55\n",
            "Params size (MB): 69.42\n",
            "Estimated Total Size (MB): 288.55\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ],
      "source": [
        "!pip install torchsummary\n",
        "from torchsummary import summary\n",
        "summary(model, input_size=(3,224,224), device=device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aJoiV7T2oMRc"
      },
      "outputs": [],
      "source": [
        "def train_batch(data, model, optimizer, criteria):\n",
        "    model.train()\n",
        "    ims, age, gender = data\n",
        "    optimizer.zero_grad()\n",
        "    pred_gender, pred_age = model(ims)    \n",
        "    gender_criterion, age_criterion = criteria\n",
        "    gender_loss = gender_criterion(pred_gender.squeeze(), gender)\n",
        "    age_loss = age_criterion(pred_age.squeeze(), age)\n",
        "    total_loss = gender_loss + age_loss\n",
        "    total_loss.backward()\n",
        "    optimizer.step()\n",
        "    return total_loss\n",
        "\n",
        "def validate_batch(data, model, criteria):\n",
        "    model.eval()\n",
        "    ims, age, gender = data\n",
        "    with torch.no_grad():\n",
        "      pred_gender, pred_age = model(ims)\n",
        "    gender_criterion, age_criterion = criteria\n",
        "    gender_loss = gender_criterion(pred_gender.squeeze(), gender)\n",
        "    age_loss = age_criterion(pred_age.squeeze(), age)\n",
        "    total_loss = gender_loss + age_loss\n",
        "    pred_gender = (pred_gender > 0.5).squeeze()\n",
        "    gender_acc = (pred_gender == gender).float().sum()\n",
        "    age_mae = torch.abs(age - pred_age).float().sum()\n",
        "    return total_loss, gender_acc, age_mae"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uhbO3pA0oTuc",
        "outputId": "e67a2fa1-5939-4ce6-8651-c0d83c65cda0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1/5 (844.58s - 4222.92s remaining)\n",
            "Epoch: 001\tTrain Loss: 0.548\tTest: 0.469\tBest Test Loss: 0.4695\n",
            "Gender Accuracy: 83.54%\tAge MAE: 6.34\n",
            "\n",
            "2/5 (1682.39s - 3364.79s remaining)\n",
            "Epoch: 002\tTrain Loss: 0.400\tTest: 0.440\tBest Test Loss: 0.4399\n",
            "Gender Accuracy: 84.88%\tAge MAE: 6.23\n",
            "\n",
            "3/5 (2526.27s - 2526.27s remaining)\n",
            "Epoch: 003\tTrain Loss: 0.286\tTest: 0.494\tBest Test Loss: 0.4399\n",
            "Gender Accuracy: 84.67%\tAge MAE: 6.27\n",
            "\n",
            "4/5 (3370.63s - 1685.32s remaining)\n",
            "Epoch: 004\tTrain Loss: 0.199\tTest: 0.613\tBest Test Loss: 0.4399\n",
            "Gender Accuracy: 83.80%\tAge MAE: 6.41\n",
            "\n",
            "5/5 (4208.70s - 841.74s remaining)\n",
            "Epoch: 005\tTrain Loss: 0.159\tTest: 0.710\tBest Test Loss: 0.4399\n",
            "Gender Accuracy: 83.30%\tAge MAE: 6.29\n",
            "\n"
          ]
        }
      ],
      "source": [
        "model, criteria, optimizer = get_model()\n",
        "val_gender_accuracies = []\n",
        "val_age_maes = []\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "\n",
        "n_epochs = 5\n",
        "best_test_loss = 1000\n",
        "start = time.time()\n",
        "\n",
        "for epoch in range(n_epochs):\n",
        "    epoch_train_loss, epoch_test_loss = 0, 0\n",
        "    val_age_mae, val_gender_acc, ctr = 0, 0, 0\n",
        "    _n = len(train_loader)\n",
        "    for ix, data in enumerate(train_loader):\n",
        "        # if ix == 100: break\n",
        "        loss = train_batch(data, model, optimizer, criteria)\n",
        "        epoch_train_loss += loss.item()\n",
        "\n",
        "    for ix, data in enumerate(test_loader):\n",
        "        # if ix == 10: break\n",
        "        loss, gender_acc, age_mae = validate_batch(data, model, criteria)\n",
        "        epoch_test_loss += loss.item()\n",
        "        val_age_mae += age_mae\n",
        "        val_gender_acc += gender_acc\n",
        "        ctr += len(data[0])\n",
        "\n",
        "    val_age_mae /= ctr\n",
        "    val_gender_acc /= ctr\n",
        "    epoch_train_loss /= len(train_loader)\n",
        "    epoch_test_loss /= len(test_loader)\n",
        "\n",
        "    elapsed = time.time()-start\n",
        "    best_test_loss = min(best_test_loss, epoch_test_loss)\n",
        "    print('{}/{} ({:.2f}s - {:.2f}s remaining)'.format(epoch+1, n_epochs, time.time()-start, (n_epochs-epoch)*(elapsed/(epoch+1))))\n",
        "    info = f'''Epoch: {epoch+1:03d}\\tTrain Loss: {epoch_train_loss:.3f}\\tTest: {epoch_test_loss:.3f}\\tBest Test Loss: {best_test_loss:.4f}'''\n",
        "    info += f'\\nGender Accuracy: {val_gender_acc*100:.2f}%\\tAge MAE: {val_age_mae:.2f}\\n'\n",
        "    print(info)\n",
        "\n",
        "    val_gender_accuracies.append(val_gender_acc)\n",
        "    val_age_maes.append(val_age_mae)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 350
        },
        "id": "akzO0Z3Br2GP",
        "outputId": "557b3b50-82c3-42df-dacf-2ee4f54c34c9"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light",
            "tags": []
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "epochs = np.arange(1,len(val_gender_accuracies)+1)\n",
        "fig,ax = plt.subplots(1,2,figsize=(10,5))\n",
        "ax = ax.flat\n",
        "ax[0].plot(epochs, val_gender_accuracies, 'bo')\n",
        "ax[1].plot(epochs, val_age_maes, 'r')\n",
        "ax[0].set_xlabel('Epochs')\n",
        "ax[1].set_xlabel('Epochs')\n",
        "ax[0].set_ylabel('Accuracy')\n",
        "ax[1].set_ylabel('MAE')\n",
        "ax[0].set_title('Validation Gender Accuracy')\n",
        "ax[0].set_title('Validation Age Mean-Absolute-Error')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kst7Qp5lwlhJ"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "age-gender-without-torch-snippets",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "pytorch",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.12 (main, Jun  1 2022, 06:36:29) \n[Clang 12.0.0 ]"
    },
    "vscode": {
      "interpreter": {
        "hash": "f5b916051ec391ef3c1c0123575e59cad2c35863d294dd079abc5845c0e5babb"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "169be448255e45e4b69f47740b1fc4e9": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2e780ce258ee4277b0d7e3fc99fef48e": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "7a01294a511e42b394dd62f2af3f3014": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "100%",
            "description_tooltip": null,
            "layout": "IPY_MODEL_169be448255e45e4b69f47740b1fc4e9",
            "max": 553433881,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_e6a7f4bb399f42969d624bc55fcb81e4",
            "value": 553433881
          }
        },
        "a247b4c6ac9d44ab8e4c82ccfa9d8b05": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7a01294a511e42b394dd62f2af3f3014",
              "IPY_MODEL_c029002323f34a74a873b4175906a3ea"
            ],
            "layout": "IPY_MODEL_e0597664297e4074aafb1abc74462c54"
          }
        },
        "c029002323f34a74a873b4175906a3ea": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_da9aacf457e948a9a406b0e5f7028bb0",
            "placeholder": "​",
            "style": "IPY_MODEL_2e780ce258ee4277b0d7e3fc99fef48e",
            "value": " 528M/528M [00:17&lt;00:00, 31.1MB/s]"
          }
        },
        "da9aacf457e948a9a406b0e5f7028bb0": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e0597664297e4074aafb1abc74462c54": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e6a7f4bb399f42969d624bc55fcb81e4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": "initial"
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}