AASIST audio spoof detection.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import librosa\n",
        "import numpy as np\n",
        "import torch.nn.functional as F\n",
        "from sklearn.metrics import roc_curve\n",
        "import os\n",
        "import matplotlib.pyplot as plt\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "metadata": {
        "id": "Kwq9Hx_aE1-7"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JLKgn4r_5SzM",
        "outputId": "a4bbc76f-9c98-4d8d-bc63-84f5cae912b9"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "\n",
        "class ASSIST(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(ASSIST, self).__init__()\n",
        "        \n",
        "        # define the convolutional layers\n",
        "        self.conv1 = nn.Conv1d(in_channels=1, out_channels=16, kernel_size=5, stride=2, padding=2)\n",
        "        self.bn1 = nn.BatchNorm1d(num_features=16)\n",
        "        self.pool1 = nn.MaxPool1d(kernel_size=2, stride=2)\n",
        "        \n",
        "        self.conv2 = nn.Conv1d(in_channels=16, out_channels=32, kernel_size=5, stride=2, padding=2)\n",
        "        self.bn2 = nn.BatchNorm1d(num_features=32)\n",
        "        self.pool2 = nn.MaxPool1d(kernel_size=2, stride=2)\n",
        "        \n",
        "        self.conv3 = nn.Conv1d(in_channels=32, out_channels=64, kernel_size=5, stride=2, padding=2)\n",
        "        self.bn3 = nn.BatchNorm1d(num_features=64)\n",
        "        self.pool3 = nn.MaxPool1d(kernel_size=2, stride=2)\n",
        "        \n",
        "        # define the fully connected layers\n",
        "        self.fc1 = nn.Linear(in_features=80000, out_features=128)\n",
        "        self.dropout = nn.Dropout(p=0.5)\n",
        "        self.fc2 = nn.Linear(in_features=128, out_features=2)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        # apply the convolutional layers\n",
        "        x = x.view(x.shape[0],1, x.shape[1])\n",
        "\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.pool1(x)\n",
        "        \n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.pool2(x)\n",
        "        \n",
        "        x = self.conv3(x)\n",
        "        x = self.bn3(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.pool3(x)\n",
        "        \n",
        "        # reshape the output of the convolutional layers\n",
        "        x = x.view(x.size(0), -1)\n",
        "        \n",
        "        # apply the fully connected layers\n",
        "        x = self.fc1(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.dropout(x)\n",
        "        x = self.fc2(x)\n",
        "        \n",
        "        return x\n"
      ],
      "metadata": {
        "id": "y03CaINwe12N"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "path = '/content/drive/MyDrive/DAI/Spoof Detection/'\n",
        "os.listdir(path)"
      ],
      "metadata": {
        "id": "r1LC6bs60znL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bc1651a-6421-41a4-c9ec-242adff86752"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Audio_english', 'TTS_english']"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class AudioDataset(Dataset):\n",
        "    def __init__(self, real_audio_dir, fake_audio_dir):\n",
        "        self.real_audio_dir = real_audio_dir\n",
        "        self.fake_audio_dir = fake_audio_dir\n",
        "        self.real_audio_files = os.listdir(self.real_audio_dir)\n",
        "        self.fake_audio_files = os.listdir(self.fake_audio_dir)\n",
        "        self.sample_rate = 16000 # sample rate for all audio files\n",
        "        \n",
        "    def __len__(self):\n",
        "        return len(self.real_audio_files) + len(self.fake_audio_files)\n",
        "    \n",
        "    def __getitem__(self, idx):\n",
        "        if idx < len(self.real_audio_files):\n",
        "            audio_file = self.real_audio_files[idx]\n",
        "            label = 0 # 0 for real audio\n",
        "            audio_path = os.path.join(self.real_audio_dir, audio_file)\n",
        "        else:\n",
        "            audio_file = self.fake_audio_files[idx - len(self.real_audio_files)]\n",
        "            label = 1 # 1 for fake audio\n",
        "            audio_path = os.path.join(self.fake_audio_dir, audio_file)\n",
        "        \n",
        "        waveform, sr = librosa.load(audio_path, sr=self.sample_rate)\n",
        "        waveform = torch.from_numpy(waveform).float()\n",
        "        waveform_length = waveform.shape[0]\n",
        "        \n",
        "        # pad or truncate the waveform to have the same length\n",
        "        target_length = self.sample_rate * 5 # 5 seconds\n",
        "        if waveform_length < target_length:\n",
        "            num_missing_samples = target_length - waveform_length\n",
        "            padding = torch.zeros(num_missing_samples)\n",
        "            waveform = torch.cat((waveform, padding))\n",
        "        else:\n",
        "            waveform = waveform[:target_length]\n",
        "        \n",
        "        return waveform, label\n",
        "            \n",
        "# Define the data loaders\n",
        "dataset = AudioDataset(path+'Audio_english', path+'TTS_english')\n",
        "#test_dataset = AudioDataset('path/to/testing/data')\n",
        "\n",
        "print(len(dataset))\n",
        "\n",
        "train_dataset,test_dataset = torch.utils.data.dataset.random_split(dataset,[650,137])\n",
        "\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PelEX-vRe14E",
        "outputId": "36fc1fbb-9aae-40f4-dfd7-383268fac4e1"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "787\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = iter(test_loader)\n",
        "b = next(a)\n",
        "print(b[0].shape)\n",
        "print(b[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4PhDxgPLkd43",
        "outputId": "69e1b62c-46c2-49f9-ea5b-7359f4f3aae6"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([32, 80000])\n",
            "tensor([0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0,\n",
            "        0, 0, 1, 0, 1, 0, 0, 0])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def train(model, train_loader, test_loader, num_epochs):\n",
        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    model.to(device)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "    \n",
        "    for epoch in range(num_epochs):\n",
        "        model.train()\n",
        "        train_loss = 0\n",
        "        train_acc = 0\n",
        "        \n",
        "        for data, label in train_loader:\n",
        "            data = data.to(device)\n",
        "            label = label.to(device)\n",
        "            optimizer.zero_grad()\n",
        "            output = model(data)\n",
        "            loss = criterion(output, label)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            train_loss += loss.item()\n",
        "            pred = output.argmax(dim=1, keepdim=True)\n",
        "            train_acc += pred.eq(label.view_as(pred)).sum().item()\n",
        "        \n",
        "        train_loss /= len(train_loader.dataset)\n",
        "        train_acc /= len(train_loader.dataset)\n",
        "        \n",
        "        model.eval()\n",
        "        test_loss = 0\n",
        "        test_acc = 0\n",
        "        \n",
        "        with torch.no_grad():\n",
        "            for data, label in test_loader:\n",
        "                data = data.to(device)\n",
        "                label = label.to(device)\n",
        "                output = model(data)\n",
        "                loss = criterion(output, label)\n",
        "                test_loss += loss.item()\n",
        "                pred = output.argmax(dim=1, keepdim=True)\n",
        "                test_acc += pred.eq(label.view_as(pred)).sum().item()\n",
        "        \n",
        "        test_loss /= len(test_loader.dataset)\n",
        "        test_acc /= len(test_loader.dataset)\n",
        "        \n",
        "        print(f\"Epoch {epoch+1}: Train Loss = {train_loss:.4f}, Train Accuracy = {train_acc:.4f}, Test Loss = {test_loss:.4f}, Test Accuracy = {test_acc:.4f}\")\n",
        "\n",
        "# Train the model\n",
        "model = ASSIST()\n",
        "train(model, train_loader, test_loader, num_epochs=5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C46mGnIUfCjz",
        "outputId": "a6a55aee-d258-4be9-b31f-beec3bb95c6f"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1: Train Loss = 0.0553, Train Accuracy = 0.8754, Test Loss = 0.0516, Test Accuracy = 0.3723\n",
            "Epoch 2: Train Loss = 0.0031, Train Accuracy = 0.9923, Test Loss = 0.2226, Test Accuracy = 0.6496\n",
            "Epoch 3: Train Loss = 0.0027, Train Accuracy = 0.9892, Test Loss = 0.1240, Test Accuracy = 0.7445\n",
            "Epoch 4: Train Loss = 0.0062, Train Accuracy = 0.9923, Test Loss = 0.0026, Test Accuracy = 0.9854\n",
            "Epoch 5: Train Loss = 0.0030, Train Accuracy = 0.9923, Test Loss = 0.0007, Test Accuracy = 0.9854\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# To check on Pretrained AASIST model"
      ],
      "metadata": {
        "id": "VO1622TdxUSa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!git clone 'https://github.com/clovaai/aasist'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WDekkbRkxKcM",
        "outputId": "d60d2340-1178-43d7-82ee-a672069abf7f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'aasist'...\n",
            "remote: Enumerating objects: 38, done.\u001b[K\n",
            "remote: Counting objects: 100% (6/6), done.\u001b[K\n",
            "remote: Compressing objects: 100% (3/3), done.\u001b[K\n",
            "remote: Total 38 (delta 3), reused 3 (delta 3), pack-reused 32\u001b[K\n",
            "Unpacking objects: 100% (38/38), 1.43 MiB | 10.93 MiB/s, done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd aasist\n",
        "!pip install -r requirements.txt"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vbI1pMAWxKep",
        "outputId": "06e362a7-e905-4a34-999f-815565fefb1e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/aasist\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: torch>=1.6.0 in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 1)) (1.13.1+cu116)\n",
            "Collecting torchcontrib\n",
            "  Downloading torchcontrib-0.0.2.tar.gz (11 kB)\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 3)) (1.22.4)\n",
            "Requirement already satisfied: soundfile in /usr/local/lib/python3.8/dist-packages (from -r requirements.txt (line 4)) (0.12.1)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.8/dist-packages (from torch>=1.6.0->-r requirements.txt (line 1)) (4.5.0)\n",
            "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from soundfile->-r requirements.txt (line 4)) (1.15.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->soundfile->-r requirements.txt (line 4)) (2.21)\n",
            "Building wheels for collected packages: torchcontrib\n",
            "  Building wheel for torchcontrib (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for torchcontrib: filename=torchcontrib-0.0.2-py3-none-any.whl size=7532 sha256=e3c85e62be4ab4fd78dd4522ab83352d60a79ddbcd35644d469f0a4f0fcae400\n",
            "  Stored in directory: /root/.cache/pip/wheels/3b/75/17/b11b16ad90276ff6e4e03ec375d55291a186c7fe9dbf87fba3\n",
            "Successfully built torchcontrib\n",
            "Installing collected packages: torchcontrib\n",
            "Successfully installed torchcontrib-0.0.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Removed unnecessary content from the main.py file.\n",
        "# After making the required changes in main.py file and config files\n",
        "\n",
        "!python main.py --eval --config ./config/AASIST.conf"
      ],
      "metadata": {
        "id": "ueO6Ou-7yjVq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba626a85-735b-4284-e4a0-1e7826840df2"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1: Train Loss = 0.0603, Train Accuracy = 0.8369, Test Loss = 0.2511, Test Accuracy = 0.6496\n",
            "Epoch 2: Train Loss = 0.0114, Train Accuracy = 0.9723, Test Loss = 0.1595, Test Accuracy = 0.6642\n",
            "Epoch 3: Train Loss = 0.0059, Train Accuracy = 0.9785, Test Loss = 0.0354, Test Accuracy = 0.8978\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "criterion = nn.CrossEntropyLoss()\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "def evaluation(model,test_dl):\n",
        "    model.eval()\n",
        "    running_loss = 0.0\n",
        "    running_corrects = 0\n",
        "    total = 0\n",
        "    preds = []\n",
        "    pred_labels = []\n",
        "    labels = []\n",
        "\n",
        "            # Disable gradient calculation for validation or inference using torch.no_rad()\n",
        "    with torch.no_grad():\n",
        "        for x,y in test_dl:\n",
        "            x = x.to(device)\n",
        "            y = y.to(device) #CHW --> #HWC\n",
        "            valid_logits = model(x)\n",
        "            predict_prob = F.softmax(valid_logits)\n",
        "            _,predictions = predict_prob.max(1)\n",
        "            predictions = predictions.to('cpu')\n",
        "\n",
        "            _, valid_preds = torch.max(valid_logits, 1)\n",
        "            valid_loss = criterion(valid_logits,y)\n",
        "            running_loss += valid_loss.item() * x.size(0)\n",
        "            running_corrects += torch.sum(valid_preds == y.data)\n",
        "            total += y.size(0)\n",
        "            predict_prob = predict_prob.to('cpu')\n",
        "\n",
        "            pred_labels.extend(list(predictions.numpy()))\n",
        "            preds.extend(list(predict_prob.numpy()))\n",
        "            y = y.to('cpu')\n",
        "            labels.extend(list(y.numpy()))\n",
        "\n",
        "    epoch_loss = running_loss / len(test_dataset)\n",
        "    epoch_acc = running_corrects.double() / len(test_dataset)\n",
        "    print(\"Test Loss is {}\".format(epoch_loss))\n",
        "    print(\"Test Accuracy is {}\".format(epoch_acc.cpu()))\n",
        "    return np.array(labels),np.array(pred_labels),np.array(preds)\n",
        "\n",
        "def calculate_eer(y_test, y_pred):\n",
        "    # Calculate the false positive rate (fpr) and true positive rate (tpr)\n",
        "    fpr, tpr, thresholds = roc_curve(y_test, y_pred)\n",
        "    \n",
        "    # Find the threshold index closest to the point where fpr = 1 - tpr\n",
        "    fnr = 1 - tpr\n",
        "    eer_threshold_idx = np.argmin(np.abs(fnr - fpr))\n",
        "    \n",
        "    # Calculate EER as the average of the two closest points to the threshold\n",
        "    eer = (fpr[eer_threshold_idx] + fnr[eer_threshold_idx]) / 2\n",
        "    \n",
        "    return eer"
      ],
      "metadata": {
        "id": "RBwhUUWqFrAl"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import copy\n",
        "def roc_det(y_true,y_pred):\n",
        "    metrics = {'fpr':[],'tpr':[],'fnr':[]}\n",
        "    for i in np.arange(0,1.2,0.001):\n",
        "        new_y = copy.deepcopy(y_pred)\n",
        "        y_pred_new = (new_y > i)\n",
        "        fp = ((y_true == 0) & (y_pred_new == 1)).sum()\n",
        "        tp = ((y_true == 1) & (y_pred_new == 1)).sum()\n",
        "        fn = ((y_true == 1) & (y_pred_new == 0)).sum()\n",
        "        tn = ((y_true == 0) & (y_pred_new == 0)).sum()\n",
        "        metrics['fpr'].append(fp/(fp+tn))\n",
        "        metrics['tpr'].append(tp/(tp+fn))\n",
        "        metrics['fnr'].append(fn/(fn+tp))\n",
        "    return metrics"
      ],
      "metadata": {
        "id": "OEaW1OYCaml8"
      },
      "execution_count": 79,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "labels1, pred_labels1, preds1 = evaluation(model,test_loader)\n",
        "print('EER:', calculate_eer(labels1, pred_labels1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_8p7RWxPGwTt",
        "outputId": "f4a0fcaf-0409-4ec7-c70e-105078417745"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Loss is 0.02127577176608164\n",
            "Test Accuracy is 0.9854014598540146\n",
            "EER: 0.016034644194756573\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "metrics1 = roc_det(labels1,preds1[:,1])\n",
        "plt.plot(metrics1['fpr'],metrics1['fnr'])\n",
        "plt.title('Decision Error Trade-off (DET) Curve')\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('False Negative Rate')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "tj583-2FK6EM",
        "outputId": "494eade0-7865-48f9-c39d-068ded864663"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# model2 corresponds to the AASIST model\n",
        "labels, pred_labels, preds = evaluation(model2,test_loader)\n",
        "print('EER:', calculate_eer(labels, pred_labels))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X00twX3iFrCr",
        "outputId": "65311776-7143-4eb8-d756-0f0edd533818"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-12-67af477b36a1>:19: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
            "  predict_prob = F.softmax(valid_logits)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Loss is 0.9082689537619152\n",
            "Test Accuracy is 0.8978102189781022\n",
            "EER: 0.14583333333333331\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "metrics = roc_det(labels,preds[:,1])\n",
        "plt.plot(metrics1['fpr'],metrics1['fnr'], label = 'Our Trained Model')\n",
        "plt.plot(metrics['fpr'],metrics['fnr'], label = 'Fine Tuned Model')\n",
        "plt.legend()\n",
        "plt.title('Decision Error Trade-off (DET) Curve')\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('False Negative Rate')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "Kv4tk0VyMlPd",
        "outputId": "e88779c8-d707-4af1-d17f-5a455dce808c"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "42PsQGtlcBz6"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}