slc22a5_single_mutants.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "slc22a5_single_mutants.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOHCjqEXkC2YsF5mkhubSMi",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/captaincapsaicin/slc22a5/blob/main/slc22a5_single_mutants.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install biopython"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mUaJHLz7IUdS",
        "outputId": "df6d5b1f-7df2-42bd-adc0-ffe56583e83c"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: biopython in /usr/local/lib/python3.7/dist-packages (1.79)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from biopython) (1.21.6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Download wildtype and potts models\n",
        "\n",
        "The potts model weights are saved as npz files, which hold bias and coupling terms for trained models corresponding to alignments. See the manuscript for more details on the alignments."
      ],
      "metadata": {
        "id": "1pnbC_I17QWW"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "G3EuOkog7CxK"
      },
      "outputs": [],
      "source": [
        "# wildtype\n",
        "!wget -q http://s3.amazonaws.com/songlabdata/slc22a5/O76082.fasta\n",
        "\n",
        "# potts state dicts\n",
        "!wget -q http://s3.amazonaws.com/songlabdata/slc22a5/potts/deepsequence.npz\n",
        "!wget -q http://s3.amazonaws.com/songlabdata/slc22a5/potts/eve.npz\n",
        "!wget -q http://s3.amazonaws.com/songlabdata/slc22a5/potts/hhblits.npz\n",
        "!wget -q http://s3.amazonaws.com/songlabdata/slc22a5/potts/mammals_30.npz\n",
        "!wget -q http://s3.amazonaws.com/songlabdata/slc22a5/potts/vertebrates_100.npz"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Set up utility functions"
      ],
      "metadata": {
        "id": "LkAciBD49k5b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd"
      ],
      "metadata": {
        "id": "A-dh4Zez_xxJ"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# https://github.com/nickbhat/mogwai/blob/main/mogwai/vocab.py\n",
        "\n",
        "\n",
        "from typing import Sequence, List\n",
        "\n",
        "class _FastaVocab:\n",
        "\n",
        "    def __init__(self):\n",
        "        self.ALPHABET = \"ARNDCQEGHILKMFPSTWYV-\"\n",
        "        self.A2N = {a: n for n, a in enumerate(self.ALPHABET)}\n",
        "        self.A2N[\"X\"] = 20\n",
        "\n",
        "        self.IUPAC_CODES = {\n",
        "            \"Ala\": \"A\",\n",
        "            \"Arg\": \"R\",\n",
        "            \"Asn\": \"N\",\n",
        "            \"Asp\": \"D\",\n",
        "            \"Cys\": \"C\",\n",
        "            \"Gln\": \"Q\",\n",
        "            \"Glu\": \"E\",\n",
        "            \"Gly\": \"G\",\n",
        "            \"His\": \"H\",\n",
        "            \"Ile\": \"I\",\n",
        "            \"Leu\": \"L\",\n",
        "            \"Lys\": \"K\",\n",
        "            \"Met\": \"M\",\n",
        "            \"Phe\": \"F\",\n",
        "            \"Pro\": \"P\",\n",
        "            \"Ser\": \"S\",\n",
        "            \"Thr\": \"T\",\n",
        "            \"Trp\": \"W\",\n",
        "            \"Val\": \"V\",\n",
        "            \"Tyr\": \"Y\",\n",
        "            \"Asx\": \"B\",\n",
        "            \"Sec\": \"U\",\n",
        "            \"Xaa\": \"X\",\n",
        "            \"Glx\": \"Z\",\n",
        "        }\n",
        "\n",
        "        self.THREE_LETTER = {aa: name for name, aa in self.IUPAC_CODES.items()}\n",
        "\n",
        "    def convert_indices_to_tokens(self, indices: Sequence[int]) -> List[str]:\n",
        "        return [self.ALPHABET[i] for i in indices]\n",
        "\n",
        "    def convert_tokens_to_indices(self, tokens: Sequence[str], skip_unknown: bool = False) -> List[int]:\n",
        "        if skip_unknown:\n",
        "            return [self.A2N[token] for token in tokens if token in self.A2N]\n",
        "        else:\n",
        "            return [self.A2N.get(token, 20) for token in tokens]\n",
        "\n",
        "    def tokenize(self, sequence: str) -> List[int]:\n",
        "        return self.convert_tokens_to_indices(list(sequence))\n",
        "\n",
        "    def __len__(self) -> int:\n",
        "        return 20\n",
        "\n",
        "    @property\n",
        "    def pad_idx(self) -> int:\n",
        "        return 20\n",
        "\n",
        "\n",
        "FastaVocab = _FastaVocab()"
      ],
      "metadata": {
        "id": "jdHC8BCM-g6I"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# https://github.com/google-research/slip/blob/main/utils.py#L27\n",
        "def onehot(labels, num_classes):\n",
        "  \"\"\"Convert integer encoded sequences to onehot format.\n",
        "  Args:\n",
        "    labels: 2D ndarray of integer-encoded sequences, num_seqs x seq_len\n",
        "    num_classes: Number of classes\n",
        "  Returns:\n",
        "    3D onehot encoded array, num_seqs x seq_len x num_classes\n",
        "  \"\"\"\n",
        "  if len(np.shape(labels)) == 3:  # if already one-hot, return labels\n",
        "    return labels\n",
        "  elif isinstance(labels, list):\n",
        "    labels = np.asarray(labels)  # ndarray view\n",
        "  x = (labels[Ellipsis, None] == np.arange(num_classes)[None])\n",
        "  return x.astype(np.float32)"
      ],
      "metadata": {
        "id": "5p0KAUzU7Vam"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# https://github.com/google-research/slip/blob/main/sampling.py#L76\n",
        "\n",
        "def get_all_single_mutants(sequence,\n",
        "                           vocab_size):\n",
        "  \"\"\"Returns all single mutants of given `sequence`.\n",
        "  For a given sequence, at each position there are `vocab_size` - 1 possible\n",
        "  mutations.\n",
        "  Args:\n",
        "    sequence: A 1d vector of ints.\n",
        "    vocab_size: The vocabulary size.\n",
        "  Returns:\n",
        "    A [(V-1)*L, L] numpy array of integer encoded sequences, where L is the\n",
        "    length of the sequence and V is the vocab size.\n",
        "  \"\"\"\n",
        "  sequence = np.array(sequence)\n",
        "  seq_length = len(sequence)\n",
        "\n",
        "  all_singles = []\n",
        "  for pos in range(seq_length):\n",
        "    num_singles = vocab_size - 1\n",
        "    singles_at_pos = np.tile(sequence, (num_singles, 1))\n",
        "    delta = np.arange(1, vocab_size, 1)\n",
        "    singles_at_pos[:, pos] = (singles_at_pos[:, pos] + delta) % vocab_size\n",
        "    all_singles.append(singles_at_pos)\n",
        "  return np.vstack(all_singles)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# https://github.com/google-research/slip/blob/main/potts_model.py#L315\n",
        "def load_from_mogwai_statedict(path):\n",
        "    state_dict = np.load(path)\n",
        "    couplings = -1 * state_dict['weight']\n",
        "    bias = -1 * state_dict['bias']\n",
        "    \n",
        "    # Reshape the couplings from Mogwai. L, A, L, A -> L, L, A, A\n",
        "    couplings = np.moveaxis(couplings, [0, 1, 2, 3], [0, 2, 1, 3])\n",
        "    return bias, couplings\n",
        "\n",
        "def potts_energy(sequences, couplings, field, vocab_size=20):\n",
        "  \"\"\"Compute the Potts model energy.\"\"\"\n",
        "  if len(np.asarray(sequences).shape) == 1:  # single sequence\n",
        "    sequences = np.reshape(sequences, (1, -1))\n",
        "  # one-hot representation\n",
        "  onehot_seq = onehot(sequences, num_classes=vocab_size)\n",
        "  # (i, j, k, l, b) = (residue1, residue2, amino1, amino2, batch)\n",
        "  linear_term = np.einsum(\n",
        "      'ij,bij->b', field, onehot_seq, optimize='optimal') \n",
        "  quadratic_term = 0.5 * np.einsum(\n",
        "      'ijkl,bik,bjl->b',\n",
        "      couplings,\n",
        "      onehot_seq,\n",
        "      onehot_seq,\n",
        "      optimize='optimal')\n",
        "\n",
        "  return linear_term + quadratic_term\n",
        "\n"
      ],
      "metadata": {
        "id": "e2H7owHB95hz"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from Bio import SeqIO\n",
        "\n",
        "def get_wildtype():\n",
        "    \"\"\"Read the wildtype sequence\n",
        "\n",
        "    Returns\n",
        "        Bio.Seq\n",
        "    \"\"\"\n",
        "    wildtype_fasta = \"O76082.fasta\"\n",
        "    with open(wildtype_fasta, \"rU\") as f:\n",
        "        for record in SeqIO.parse(f, \"fasta\"):\n",
        "            octn2_wildtype = record.seq\n",
        "    return octn2_wildtype\n",
        "\n",
        "\n",
        "def get_mutation_strings(sequences, reference_sequence):\n",
        "    mutation_strings = []\n",
        "    for sequence in sequences:\n",
        "        mutation_string = ''\n",
        "        differences = sequence != reference_sequence\n",
        "        for i in range(len(differences)):\n",
        "            if differences[i]:\n",
        "                ref_aa = FastaVocab.ALPHABET[reference_sequence[i]]\n",
        "                aa = FastaVocab.ALPHABET[sequence[i]]\n",
        "                index = i\n",
        "                mutation_string += '{}{}{} '.format(ref_aa, index, aa)\n",
        "        mutation_strings.append(mutation_string.strip())\n",
        "    return mutation_strings\n",
        "\n",
        "def get_single_mutant_energies_for_alignment(path, reference_seq):\n",
        "    bias, couplings = load_from_mogwai_statedict(path)\n",
        "\n",
        "    single_mutants = get_all_single_mutants(reference_seq, vocab_size=20)\n",
        "    sequences = np.vstack([reference_seq, single_mutants])\n",
        "    energies = potts_energy(sequences, couplings, bias, vocab_size=20) \n",
        "    \n",
        "    reference_energy = potts_energy(reference_seq, couplings, bias, vocab_size=20)\n",
        "    delta_energies = energies - reference_energy  # normalize to 0\n",
        "    mutation_strings = get_mutation_strings(sequences, reference_seq)\n",
        "    return {'delta_energy': delta_energies, 'energy': energies, 'mutation_string': mutation_strings}"
      ],
      "metadata": {
        "id": "rTuDbcFA_J2m"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Compute single mutant energies and save to CSV"
      ],
      "metadata": {
        "id": "Knz1nt3LJKKA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "wildtype_seq = get_wildtype()\n",
        "tokenized_wildtype = FastaVocab.tokenize(wildtype_seq)\n",
        "\n",
        "name_to_filename = {'hhblits': 'hhblits.npz',\n",
        "                    'deepsequence': 'deepsequence.npz',\n",
        "                    'eve': 'eve.npz',\n",
        "                    '100_vertebrates': 'vertebrates_100.npz',\n",
        "                    '30_mammals': 'mammals_30.npz'\n",
        "}\n",
        "\n",
        "for name, filename in name_to_filename.items():\n",
        "    print(name)\n",
        "    path = filename\n",
        "    single_mutant_dict = get_single_mutant_energies_for_alignment(path, tokenized_wildtype)\n",
        "    df = pd.DataFrame.from_dict(single_mutant_dict)\n",
        "    outfile = '{}_single_mutant_energies.csv'.format(name)\n",
        "    df.to_csv(outfile)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L3Rt3RWi-Cp4",
        "outputId": "3f158449-b604-4ec4-bd5c-698e8c2794c3"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:10: DeprecationWarning: 'U' mode is deprecated\n",
            "  # Remove the CWD from sys.path while we load stuff.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hhblits\n",
            "deepsequence\n",
            "eve\n",
            "100_vertebrates\n",
            "30_mammals\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "def get_position_from_mutation_string(mutation_string):\n",
        "    if len(mutation_string) == 0: # wildtype\n",
        "        return None\n",
        "    index = mutation_string[1:-1]\n",
        "    return int(index)\n",
        "\n",
        "alignment = 'hhblits'\n",
        "df = pd.read_csv('{}_single_mutant_energies.csv'.format(alignment))\n",
        "df = df.dropna()  # get rid of wildtype rows\n",
        "df['position'] = df.mutation_string.apply(get_position_from_mutation_string)"
      ],
      "metadata": {
        "id": "hIdBrG7g-aaN"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Do a quick visualization of which positions are worst"
      ],
      "metadata": {
        "id": "t4EFAqXLNYU_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12, 6))\n",
        "grouped_df = df.groupby('position').agg({'delta_energy': 'mean'}).reset_index()\n",
        "sns.scatterplot(data=grouped_df, x='position', y='delta_energy', s=16)\n",
        "plt.title(f'Average delta energy per position for {alignment}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 421
        },
        "id": "kzJQLvTkK3E2",
        "outputId": "ec302049-9ccc-406c-d4bb-3cbba90acb1a"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Average delta energy per position for hhblits')"
            ]
          },
          "metadata": {},
          "execution_count": 10
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "grouped_df.sort_values(by='delta_energy', ascending=False).head(10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "iVIF81RBLqV6",
        "outputId": "d5dcba82-aab8-415f-cb66-8700ca05a347"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     position  delta_energy\n",
              "153       153      9.622983\n",
              "357       357      9.501696\n",
              "292       292      9.243228\n",
              "410       410      9.178557\n",
              "382       382      9.158614\n",
              "385       385      9.142026\n",
              "398       398      9.137246\n",
              "360       360      9.059814\n",
              "168       168      9.032586\n",
              "455       455      9.007543"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-eca55b4e-0a42-431d-8a9d-43a6c0c8b05c\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>position</th>\n",
              "      <th>delta_energy</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>153</th>\n",
              "      <td>153</td>\n",
              "      <td>9.622983</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>357</th>\n",
              "      <td>357</td>\n",
              "      <td>9.501696</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>292</th>\n",
              "      <td>292</td>\n",
              "      <td>9.243228</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>410</th>\n",
              "      <td>410</td>\n",
              "      <td>9.178557</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>382</th>\n",
              "      <td>382</td>\n",
              "      <td>9.158614</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>385</th>\n",
              "      <td>385</td>\n",
              "      <td>9.142026</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>398</th>\n",
              "      <td>398</td>\n",
              "      <td>9.137246</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>360</th>\n",
              "      <td>360</td>\n",
              "      <td>9.059814</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>168</th>\n",
              "      <td>168</td>\n",
              "      <td>9.032586</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>455</th>\n",
              "      <td>455</td>\n",
              "      <td>9.007543</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-eca55b4e-0a42-431d-8a9d-43a6c0c8b05c')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-eca55b4e-0a42-431d-8a9d-43a6c0c8b05c button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-eca55b4e-0a42-431d-8a9d-43a6c0c8b05c');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "7mumYI86NdzJ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}