Notebooks/Images/generative_adversarial_nets/protein_gan.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "C1W3: ProteinGAN (Optional)",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ViSpF4I70O4b"
      },
      "source": [
        "# ProteinGAN: Generative Adversarial Network for Functional Protein Generation\n",
        "*Please note that this is an optional notebook that is meant to introduce more advanced concepts, if you're up for a challenge. So, don't worry if you don't completely follow every step! We provide external resources for extra base knowledge required to grasp some components of the advanced material.*\n",
        "\n",
        "[ProteinGAN](https://www.biorxiv.org/content/10.1101/789719v2) was developed by [Biomatters Designs](https://www.biomatterdesigns.com/) and [Zelezniak lab at Chalmers University of Technology](https://twitter.com/AZelezniak).\n",
        "\n",
        "## Goal\n",
        "The goal of this notebook is to demonstrate that core GAN ideas can be applied outside of the image domain. In this notebook, you will be able to play around with a pre-trained ProteinGAN model to see how it can be used in bioinformatics to generate functional molecules.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q04P9icA8xIK"
      },
      "source": [
        "## Background\n",
        "\n",
        "\n",
        "### Proteins\n",
        "\n",
        "Proteins are large, complex molecules that play many critical roles in living organisms, including humans. You can think of them as very tiny, programmable robots used by nature to perform various functions, e.g. building, modifying or breaking down other molecules, aiding in cell replication and division, and transporting other proteins inside of cells. Apart from the crucial cellular functions, proteins are used virtually everywhere in our daily life, starting from animal nutrition and washing powders down to costly drugs and therapeutic antibodies. Using synthetic biology, protein engineering, adaptive evolutions experimental techniques, researchers enhance proteins' properties, making them more active or \"sticky\" towards a particular drug target or resistant to harsh environemental conditions. However, it is challenging to randomly modify proteins in a \"biochemically meaningful\" way such that protein would remain functional leading in a very costly time-consuming experiments. Thus generating natural-like diverse proteins that remain functional is of outstanding importance for biotechnology and biomedical applications. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 621
        },
        "id": "6BRDjqgjZgkg",
        "outputId": "5a8d46cb-bdd1-4d79-86a0-5af3523822f1"
      },
      "source": [
        "from IPython.display import YouTubeVideo\n",
        "YouTubeVideo('wJyUtbn0O5Y', start=75, end=80, autoplay=1, controls=0, loop=1, width=800, height=600)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"800\"\n",
              "            height=\"600\"\n",
              "            src=\"https://www.youtube.com/embed/wJyUtbn0O5Y?start=75&end=80&autoplay=1&controls=0&loop=1\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "        ></iframe>\n",
              "        "
            ],
            "text/plain": [
              "<IPython.lib.display.YouTubeVideo at 0x7f3988bd01d0>"
            ],
            "image/jpeg": "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\n"
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rLPKgWGCZdL7"
      },
      "source": [
        "*Above, animation of motor protein responsible for transporting objects in cells*\n",
        "\n",
        "Source: https://www.youtube.com/watch?v=wJyUtbn0O5Y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l2PDRSD4kDTR"
      },
      "source": [
        "\n",
        "Proteins, like images, can be represented in various ways on the computer. Images are represented as integers from 0 to 256 that indicate the intensity of red, green, or blue (RGB) color. Proteins, similarly, use letters to represent 20 unique amino acids, like the one below: \n",
        "\n",
        "> MKYATLLEYAFQALKNSYAPYSRFRVGAALLSDDGEVVTGCNVENASYGLSMCAERTAVFRAVAQGVKKFDAIAVVSGKVNPVYPCGACRQVLREFNPRLTVVVAGPGKKPLTTSLDKLLPKSFGKESLRRR\n",
        "\n",
        "Raw pixel RGB values are easy for computers to work with, though they are not very meaningful to the human eye, which is why they are displayed as images on the screen. Similarly, the sequence of amino acids is a compact, convenient representation of the actual molecule, while the more meaningful view of the protein molecule is its 3D structure. For an example, see [Cytidine deaminase](https://colab.research.google.com/drive/1O0_wyl3i-9F-5mDTlShaMfR2uOWHKwwE#scrollTo=Q277ab8R9WEU).\n",
        " \n",
        "For you to appreciate and reason about the outputs, you want your models (GANs) to ultimately produce meaningful structures. There are two important common features that make images and proteins both suitable candidates for GANs:\n",
        "\n",
        "* A random combination of building blocks, whether amino acids or pixels, will not produce a realistic outcomes. This means the GAN cannot simply guess! There are meaningful, realistic patterns of pixels and amino acids that it must model and generate.\n",
        "* The mathematical formula for how to evaluate the correctness of the generated item is unknown. For images, correctness is  \"realism\" -- how realistic does a generated image of a dog look? There's no math formula for that, so instead you have another model (the discriminator!) learn to assess that. The same goes for proteins.\n",
        "\n",
        "\n",
        "|         | Image      | Protein  |\n",
        "| ------- |:----------:| --------:|\n",
        "| Data type | integers from 0 to 256 | vocab of 20 amino acids |\n",
        "| Dimension| 2D | 1D|\n",
        "| Number of possible variants | $3*256^{size}$ |  $20^{length}$  |\n",
        "\n",
        " \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8huQi0yQ8qla"
      },
      "source": [
        "### ProteinGAN\n",
        " \n",
        "ProteinGAN is a generative adversarial network adapted to generate functional protein sequences. At its core, it consists of common building blocks: a discriminator and generator, spectral normalization (as in the [SN-GAN optional notebook](https://www.coursera.org/learn/build-basic-generative-adversarial-networks-gans/ungradedLab/c2FPs/optional-sn-gan)), and a loss function based on earth mover's distance (as in the [WGAN-GP assignment](https://www.coursera.org/learn/build-basic-generative-adversarial-networks-gans/programming/mTm3U/wgan)), etc. \n",
        "\n",
        "To make the GAN concept work in the field of synthetic biology, the generator and discriminator architectures have been modified to handle sequences of categorical values, capture long-distance relationships, as well as discriminate between various areas in the sequences. This is a major difference from pixel values in images and helps specifically with this type of long, categorical, and sequential data. One question to mull over: could this data processing and understanding help with generating text? \n",
        "\n",
        "\n",
        "**Data pre-processing.** The explored protein space is very unevenly distributed. Some proteins and their close variants are widely studied while others are just recorded in public databases. Without the balancing, the neural network mainly focuses on big clusters of similar well-studied sequences while treating unrepresented cluster members as anomalies. ProteinGAN has in-built upsampling capability to balance the dataset based on the size of the cluster in order to preserve the diversity of sequences.\n",
        "\n",
        "**Discrete values.** One of the biggest differences between images and proteins is the data type: while images consist of continuous values, proteins are built from discrete building blocks. To address this challenge for backpropagation, ProteinGAN employs the [Gumbel-Softmax trick with temperature](https://arxiv.org/abs/1611.01144), which serves as a differentiable approximation to sampling discrete data. This allows to end-to-end training of the discriminator and generator while operating in discrete input space. \n",
        "\n",
        "**Convergence.** GANs are known to be difficult to train due to stability issues. The discrete nature of the input further aggravates this problem. Despite the implementation of spectral normalization and WGAN loss, the optimization of ProteinGAN did not lead to convergence. However, as demonstrated in [this paper](https://arxiv.org/abs/1801.04406), training with zero-centered gradient penalties leads to improved training and guarantees local convergence even if data and generator distributions are not continuous. Adapting the implementation of [non-saturating loss with R1 regularization](https://arxiv.org/abs/1801.04406) greatly improves the performance of the GAN as demonstrated in the figure below.\n",
        "\n",
        "\n",
        "![Loss performance](https://drive.google.com/uc?export=view&id=1GBwiEm328DeLV29F7gUzUHP-o1uIYqSK)\n",
        "\n",
        "> *GAN performance in the first 35k steps using different losses. Model performances were measured using [BLOSUM45 scores](https://en.wikipedia.org/wiki/BLOSUM) (in the nutshell, similarity score which takes into account substitution probabilities of amino acids in known seuqences) against training sequences for the first 35,000 steps (average of 3 runs with different random seeds).*\n",
        "\n",
        "\n",
        "For more information please refer [ProteinGAN paper](https://www.biorxiv.org/content/10.1101/789719v2) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "scLQLcKcIeSS"
      },
      "source": [
        "## Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ogtiZDjSjiOJ",
        "outputId": "ffe7ea1c-91c8-49ec-98c2-71a58d81202b"
      },
      "source": [
        "# Installing dependencies\n",
        "! pip install biopython\n",
        "! pip install py3Dmol\n",
        "! apt-get install -y clustalo"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting biopython\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/76/02/8b606c4aa92ff61b5eda71d23b499ab1de57d5e818be33f77b01a6f435a8/biopython-1.78-cp36-cp36m-manylinux1_x86_64.whl (2.3MB)\n",
            "\u001b[K     |████████████████████████████████| 2.3MB 12.4MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from biopython) (1.19.4)\n",
            "Installing collected packages: biopython\n",
            "Successfully installed biopython-1.78\n",
            "Collecting py3Dmol\n",
            "  Downloading https://files.pythonhosted.org/packages/dd/19/dd527b0db65e730e20c3d5e5a7efbb7fbbf8d98f9debfb47962c13f479d6/py3Dmol-0.9.1-py2.py3-none-any.whl\n",
            "Installing collected packages: py3Dmol\n",
            "Successfully installed py3Dmol-0.9.1\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following additional packages will be installed:\n",
            "  libargtable2-0\n",
            "The following NEW packages will be installed:\n",
            "  clustalo libargtable2-0\n",
            "0 upgraded, 2 newly installed, 0 to remove and 15 not upgraded.\n",
            "Need to get 276 kB of archives.\n",
            "After this operation, 683 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu bionic/universe amd64 libargtable2-0 amd64 13-1 [13.6 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu bionic/universe amd64 clustalo amd64 1.2.4-1 [263 kB]\n",
            "Fetched 276 kB in 0s (3,311 kB/s)\n",
            "Selecting previously unselected package libargtable2-0.\n",
            "(Reading database ... 145480 files and directories currently installed.)\n",
            "Preparing to unpack .../libargtable2-0_13-1_amd64.deb ...\n",
            "Unpacking libargtable2-0 (13-1) ...\n",
            "Selecting previously unselected package clustalo.\n",
            "Preparing to unpack .../clustalo_1.2.4-1_amd64.deb ...\n",
            "Unpacking clustalo (1.2.4-1) ...\n",
            "Setting up libargtable2-0 (13-1) ...\n",
            "Setting up clustalo (1.2.4-1) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Processing triggers for libc-bin (2.27-3ubuntu1.2) ...\n",
            "/sbin/ldconfig.real: /usr/local/lib/python3.6/dist-packages/ideep4py/lib/libmkldnn.so.0 is not a symbolic link\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kEbt5Aq9YSyL",
        "outputId": "df25a09e-b727-4c6e-af68-89fa2e4e7778"
      },
      "source": [
        "# Downloading pre-trained ProteinGAN model\n",
        "!gdown https://drive.google.com/uc?id=1BfDNgn3Hj2khPfkbjE8azY_yj19igb_n\n",
        "!unzip pre_trained_protein_gan.zip"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1BfDNgn3Hj2khPfkbjE8azY_yj19igb_n\n",
            "To: /content/pre_trained_protein_gan.zip\n",
            "466MB [00:02, 201MB/s]\n",
            "Archive:  pre_trained_protein_gan.zip\n",
            "   creating: pre_trained_protein_gan/\n",
            "  inflating: pre_trained_protein_gan/saved_model.pb  \n",
            "  inflating: pre_trained_protein_gan/train_rep.fasta  \n",
            "   creating: pre_trained_protein_gan/variables/\n",
            "  inflating: pre_trained_protein_gan/variables/variables.data-00000-of-00001  \n",
            "  inflating: pre_trained_protein_gan/variables/variables.index  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7F9vYRgXV2uf"
      },
      "source": [
        "# Helper methods\n",
        "import shutil\n",
        "\n",
        "from Bio.Blast import NCBIWWW\n",
        "from Bio.Blast import NCBIXML\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "import py3Dmol\n",
        "\n",
        "# A mapping between amino acids ids and their corresponding letters\n",
        "ID_TO_AMINO_ACID = {0: '0', 1: 'A', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'K', 10: 'L', 11: 'M', 12: 'N', 13: 'P', 14: 'Q', 15: 'R', 16: 'S', 17: 'T', 18: 'V', 19: 'W', 20: 'Y'}\n",
        "\n",
        "def to_seqs(model_output):\n",
        "  \"\"\"Takes ProteinGAN output and returns list of generated protein sequences\"\"\"\n",
        "  human_readable_seqs = []\n",
        "  seqs = model_output[\"prediction\"]\n",
        "  for i in range(len(seqs)):\n",
        "    human_readable_seq =\"\".join([ID_TO_AMINO_ACID[a] for a in seqs[i].numpy()])\n",
        "    human_readable_seq = human_readable_seq.replace(\"0\", \"\")\n",
        "    human_readable_seqs.append(human_readable_seq)\n",
        "  return human_readable_seqs\n",
        "\n",
        "def get_blast_results(seq):\n",
        "  \"\"\"Takes a protein sequence, calls BLAST server and returns parsed results\"\"\"\n",
        "  print(\"Calling BLAST server. This might take a while\")\n",
        "  r = NCBIWWW.qblast(\"blastp\", \"nr\", seq, hitlist_size = 5, expect=0.5, \n",
        "                     word_size=6, matrix_name=\"BLOSUM62\")\n",
        "  blast_record = NCBIXML.read(r)\n",
        "\n",
        "  to_df = []\n",
        "\n",
        "  for a in blast_record.alignments:\n",
        "    to_df.append({\"name\": a.hit_def,\"identity\": a.hsps[0].identities,\n",
        "                  \"subject\": a.hsps[0].sbjct})\n",
        "\n",
        "  return pd.DataFrame(to_df)\n",
        "\n",
        "def append_to_fasta(path, seqs, prefix):\n",
        "  \"\"\"Appends new sequences to existing file in FASTA format.\"\"\"\n",
        "  fasta = \"\"\n",
        "  for i, seq in enumerate(seqs):\n",
        "    fasta += f\">{prefix}_{i}\\n{seq}\\n\"\n",
        "  print(fasta, file=open(path, 'a'))\n",
        "\n",
        "def interpolate(starting, ending, steps):\n",
        "  \"\"\"\n",
        "  Interpolates between starting and end points. Steps parameter determines \n",
        "  how many interpolated points will be returned.\n",
        "  \"\"\"\n",
        "  points = [starting]\n",
        "  step = (ending-starting)/steps\n",
        "  for i in range(steps):\n",
        "    starting = starting + step\n",
        "    points.append(starting)\n",
        "  return np.asanyarray(points)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q277ab8R9WEU"
      },
      "source": [
        "## Cytidine deaminase\n",
        "This demonstration will use a relatively small protein called *cytidine deaminase* for simplicity. Its function in organisms is essential to DNA and RNA degradation. **Our aim is to be able to create variants of this protein that exhibit different properties.**\n",
        " \n",
        "Below is an example of cytidine deaminase 3D structure.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 531
        },
        "id": "J7EFUwbbWy9X",
        "outputId": "f60ba6c1-5c64-4c73-e223-4388029743b4"
      },
      "source": [
        "view = py3Dmol.view(query='pdb:1UX1')\n",
        "view.setStyle({'cartoon':{'color':'spectrum'}})\n",
        "print(\"Cytidine deaminase\")\n",
        "view"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cytidine deaminase\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/3dmoljs_load.v0": "<div id=\"3dmolviewer_16094282263750064\"  style=\"position: relative; width: 640px; height: 480px\">\n        <p id=\"3dmolwarning_16094282263750064\" style=\"background-color:#ffcccc;color:black\">You appear to be running in JupyterLab (or JavaScript failed to load for some other reason).  You need to install the 3dmol extension: <br>\n        <tt>jupyter labextension install jupyterlab_3dmol</tt></p>\n        </div>\n<script>\n\nvar loadScriptAsync = function(uri){\n  return new Promise((resolve, reject) => {\n    var tag = document.createElement('script');\n    tag.src = uri;\n    tag.async = true;\n    tag.onload = () => {\n      resolve();\n    };\n  var firstScriptTag = document.getElementsByTagName('script')[0];\n  firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);\n});\n};\n\nif(typeof $3Dmolpromise === 'undefined') {\n$3Dmolpromise = null;\n  $3Dmolpromise = loadScriptAsync('https://3dmol.org/build/3Dmol.js');\n}\n\nvar viewer_16094282263750064 = null;\nvar warn = document.getElementById(\"3dmolwarning_16094282263750064\");\nif(warn) {\n    warn.parentNode.removeChild(warn);\n}\n$3Dmolpromise.then(function() {\nviewer_16094282263750064 = $3Dmol.createViewer($(\"#3dmolviewer_16094282263750064\"),{backgroundColor:\"white\"});\n$3Dmol.download(\"pdb:1UX1\", viewer_16094282263750064, {}, function() {\nviewer_16094282263750064.zoomTo();\n\tviewer_16094282263750064.setStyle({\"cartoon\": {\"color\": \"spectrum\"}});\nviewer_16094282263750064.render();\n})\n});\n</script>",
            "text/html": [
              "<div id=\"3dmolviewer_16094282263750064\"  style=\"position: relative; width: 640px; height: 480px\">\n",
              "        <p id=\"3dmolwarning_16094282263750064\" style=\"background-color:#ffcccc;color:black\">You appear to be running in JupyterLab (or JavaScript failed to load for some other reason).  You need to install the 3dmol extension: <br>\n",
              "        <tt>jupyter labextension install jupyterlab_3dmol</tt></p>\n",
              "        </div>\n",
              "<script>\n",
              "\n",
              "var loadScriptAsync = function(uri){\n",
              "  return new Promise((resolve, reject) => {\n",
              "    var tag = document.createElement('script');\n",
              "    tag.src = uri;\n",
              "    tag.async = true;\n",
              "    tag.onload = () => {\n",
              "      resolve();\n",
              "    };\n",
              "  var firstScriptTag = document.getElementsByTagName('script')[0];\n",
              "  firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);\n",
              "});\n",
              "};\n",
              "\n",
              "if(typeof $3Dmolpromise === 'undefined') {\n",
              "$3Dmolpromise = null;\n",
              "  $3Dmolpromise = loadScriptAsync('https://3dmol.org/build/3Dmol.js');\n",
              "}\n",
              "\n",
              "var viewer_16094282263750064 = null;\n",
              "var warn = document.getElementById(\"3dmolwarning_16094282263750064\");\n",
              "if(warn) {\n",
              "    warn.parentNode.removeChild(warn);\n",
              "}\n",
              "$3Dmolpromise.then(function() {\n",
              "viewer_16094282263750064 = $3Dmol.createViewer($(\"#3dmolviewer_16094282263750064\"),{backgroundColor:\"white\"});\n",
              "$3Dmol.download(\"pdb:1UX1\", viewer_16094282263750064, {}, function() {\n",
              "viewer_16094282263750064.zoomTo();\n",
              "\tviewer_16094282263750064.setStyle({\"cartoon\": {\"color\": \"spectrum\"}});\n",
              "viewer_16094282263750064.render();\n",
              "})\n",
              "});\n",
              "</script>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<py3Dmol.view at 0x7f8528e23c50>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hy4cQXYSqe7X"
      },
      "source": [
        "## Random amino acid sequence\n",
        "\n",
        "Let's consider a very naive approach first: choosing amino acids at random. As mentioned before, only a very tiny portion of amino acids can make up a protein with a desired function. So... what are the odds?\n",
        " \n",
        "There are around 17k annotated sequences that are categorized as cytidine deaminase: [see here](https://www.uniprot.org/uniprot/?query=ec%3A3.5.4.5+taxonomy%3A%22Bacteria+%5B2%5D%22+length%3A%5B64+TO+256%5D&sort=score)\n",
        " \n",
        "The protein length varies depending on the organism, but let's say you want to generate 131 length cytidine deaminase. So there are:  $20^{131}$ possible combinations (just for comparison: there are ~ $10^{80}$ atoms in the observable universe!) \n",
        " \n",
        "It's safe to say that random sequences are unlikely to work. Even brute forcing all combinations is not an option. Nevertheless, let's try to generate a sequence to see what happens. :)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "5X5tLlgIucAR",
        "outputId": "34bac72f-2d9a-455c-fda6-99e17def84f4"
      },
      "source": [
        "np.random.seed(42)\n",
        "random_seq = \"\".join(np.random.choice(list(ID_TO_AMINO_ACID.values())[1:], 131))\n",
        "random_seq"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'HYRMIHWMMEIDCNGCANNTLSRRWNYDFWHKHVEQVKCYRHNIRDQTEVIECGLEVNCLEQSRIQISPVRPKRPAHKANIMWTIDDAFLHKHKINCASFDNIDADFRQDAFQHKRRLPWHTYEFHPRMEP'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iwpDnHa7vLCv"
      },
      "source": [
        "Here, you see a 131 letter long amino acid sequence. It is hard to tell anything about this sequence only by looking. So instead, you can use a bioinformatics tool called Blast [(Basic Local Alignment Search Tool)](https://blast.ncbi.nlm.nih.gov/Blast.cgi) that searches a large database of known proteins to find the most similar matches. In most cases, a random sequence should not return any high-similarity results. \n",
        "\n",
        "If you do get anything returned, it should have a small _identity value_, which is the percentage of the sequence that matches. When the identity value is small, this means that only a small fragment of the sequence could be identified as a part of some random protein."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 49
        },
        "id": "nBoKiboYvG73",
        "outputId": "04aca09f-bac8-43e9-be8f-8d0ddc0174ff"
      },
      "source": [
        "get_blast_results(random_seq)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Calling BLAST server. This might take a while\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "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",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "Empty DataFrame\n",
              "Columns: []\n",
              "Index: []"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_P-wnHQYjvqZ"
      },
      "source": [
        "## ProteinGAN sequences\n",
        "\n",
        "What if, instead, you train a GAN to generate desirable (realistic, reasonable, non-random) protein sequences? \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o6G2mA7vPVlc"
      },
      "source": [
        "import tensorflow as tf\n",
        "tf.random.set_seed(42)\n",
        "from absl import logging\n",
        "logging.set_verbosity(\"ERROR\")\n",
        "tf.get_logger().setLevel(\"ERROR\")\n",
        "\n",
        "# Loading pre-trained model.\n",
        "model = tf.saved_model.load(\"pre_trained_protein_gan/\").signatures[\"serving_default\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "EbC5FmhhD1vI",
        "outputId": "1daf4fc2-f98a-4bcc-b289-e8bcbf6d78f4"
      },
      "source": [
        "# Choosing random points from latent space.\n",
        "noise = tf.random.truncated_normal([64, 128], stddev=0.5, dtype=tf.float32)\n",
        "\n",
        "# Feeding noise to generator to get an output.\n",
        "model_output = model(noise)\n",
        "\n",
        "# Model returns indices of amino acids. Here we convert them to actual letters.\n",
        "seqs = to_seqs(model_output)\n",
        "seqs[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'MTPEDLIEAAIRARENAHVPYSNFKVGAAIRSESGEIHAGCNIENAAYPEGWCAEAGAIFSMIRAGGREIADIGVIADSPEPISPCGACRQKIAELCTTETKIHMANLKGITQEWTMKDLLPGSFTAEDLT'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fk_9Nn7FxnG0"
      },
      "source": [
        "Again, not much can be said about the sequence just by looking at it (unless you're a protein savant). Time to run BLAST again!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "id": "TLjZJMXmpaZx",
        "outputId": "805df8ea-cf9f-4070-f5b6-7e520d44529f"
      },
      "source": [
        "get_blast_results(seqs[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Calling BLAST server. This might take a while\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "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>name</th>\n",
              "      <th>identity</th>\n",
              "      <th>subject</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>cytidine deaminase [Opitutae bacterium]</td>\n",
              "      <td>75</td>\n",
              "      <td>LFEQALRVREHAYAPYSSFKVGAALRSVSGKVYFGCNVENSAYPEG...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>cytidine deaminase [Rhodobacteraceae bacterium]</td>\n",
              "      <td>73</td>\n",
              "      <td>RENAHAPYSNFKVGAAVRSASGQIYVGCNVENVAYPEGTCAEAGAI...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>cytidine deaminase [Rhodobacteraceae bacterium...</td>\n",
              "      <td>77</td>\n",
              "      <td>SLIERARAARENAHAPYSGFGVGAALRTESGAVFAGCNAENAAYPE...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>cytidine deaminase [Albidovulum inexpectatum]</td>\n",
              "      <td>76</td>\n",
              "      <td>QSLIQAARAVRENAHAPYSGFKVGAAIRTPTGHVHVGCNVENVAYP...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>cytidine deaminase [Albidovulum inexpectatum]</td>\n",
              "      <td>76</td>\n",
              "      <td>QSLIQAARAVRENAHAPYSGFKVGAAIRTPTGHVHVGCNVENVAYP...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                                name  ...                                            subject\n",
              "0            cytidine deaminase [Opitutae bacterium]  ...  LFEQALRVREHAYAPYSSFKVGAALRSVSGKVYFGCNVENSAYPEG...\n",
              "1    cytidine deaminase [Rhodobacteraceae bacterium]  ...  RENAHAPYSNFKVGAAVRSASGQIYVGCNVENVAYPEGTCAEAGAI...\n",
              "2  cytidine deaminase [Rhodobacteraceae bacterium...  ...  SLIERARAARENAHAPYSGFGVGAALRTESGAVFAGCNAENAAYPE...\n",
              "3      cytidine deaminase [Albidovulum inexpectatum]  ...  QSLIQAARAVRENAHAPYSGFKVGAAIRTPTGHVHVGCNVENVAYP...\n",
              "4      cytidine deaminase [Albidovulum inexpectatum]  ...  QSLIQAARAVRENAHAPYSGFKVGAAIRTPTGHVHVGCNVENVAYP...\n",
              "\n",
              "[5 rows x 3 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fUKadK0Vx05y"
      },
      "source": [
        "Nice! This time, you got some matches that are either cytidine deaminase or other types of deaminase with a high indentity. This is a good indication that the GAN works well in generating realistic protein sequences."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JpAlWkRgvSJs"
      },
      "source": [
        "## Latent space\n",
        "\n",
        "As you already know, GANs learn to map points in the latent space to generated items. You can explore this latent space and perform a meaningful modifications to a generated item by moving in different directions. On generated faces, that might be changing hair color or adding sunglasses. Here, it's also to change something semantically meaningful, but for protein sequences.\n",
        "\n",
        "To start off, you can play with the diversity of generated sequences by changing how widely you sample the latent space. This can be achieved by modifying the standard deviation of the distribution. Let's try 0.1 and 1.0 to start!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ls7MUljzvRwG"
      },
      "source": [
        "# Generating sequences from points which are close to each other\n",
        "model_output = model(tf.random.truncated_normal([64, 128], stddev=0.1, dtype=tf.float32))\n",
        "small_var_seqs = to_seqs(model_output)\n",
        "\n",
        "# Generating sequences more distrbuted points\n",
        "model_output = model(tf.random.truncated_normal([64, 128], stddev=1.0, dtype=tf.float32))\n",
        "large_var_seqs = to_seqs(model_output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-Ns4dAgRYXh"
      },
      "source": [
        "# Creating fasta files which will be used for clustalo to calculate distances\n",
        "#pre_trained_protein_gan/train_rep.fasta - contains some representative sequences of training dataset\n",
        "shutil.copy(\"pre_trained_protein_gan/train_rep.fasta\",\"sequences.fasta\")\n",
        "#Appending generated sequences to training sequences\n",
        "append_to_fasta(\"sequences.fasta\", small_var_seqs, \"small_var\")\n",
        "append_to_fasta(\"sequences.fasta\", large_var_seqs, \"large_var\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xiykPRgYh4OC"
      },
      "source": [
        "[Clustalo](http://www.clustal.org/omega/) is a bioinformatics tool for biological sequence alignment and comparison that calculates the edit distances between multiple strings, taking into account that some letters are more similar than others biologically. You can use it to calculate all-to-all distances from different protein sequence sets - training representatives, sequences generated using low and high standard deviation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7D-4DqB_FcV1",
        "outputId": "8e1ecd11-2459-41fa-f7d4-9744bb603cc4"
      },
      "source": [
        "! clustalo -i sequences.fasta -o fasta.aln --threads=2 -v --full --distmat-out=dist_out.dist --force"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using 2 threads\n",
            "Read 484 sequences (type: Protein) from sequences.fasta\n",
            "Calculating pairwise ktuple-distances...\n",
            "Pairwise distance matrix written to dist_out.dist\n",
            "Ktuple-distance calculation progress done. CPU time: 7.59u 0.02s 00:00:07.61 Elapsed: 00:00:04\n",
            "Guide-tree computation done.\n",
            "Progressive alignment progress done. CPU time: 27.00u 0.82s 00:00:27.82 Elapsed: 00:00:15\n",
            "Alignment written to fasta.aln\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NIm7_vnPcKe4"
      },
      "source": [
        "from sklearn.manifold import TSNE\n",
        "\n",
        "#Loading calculated distances\n",
        "distance_matrix = pd.read_csv(\"dist_out.dist\", delimiter='\\s+', skiprows=[0],header=None,index_col=0)\n",
        "distance_matrix.columns = distance_matrix.index.values\n",
        "\n",
        "#Using TSNE to compress all pair wise distances between sequences into two components which then could be plotted.\n",
        "tsne = TSNE(n_components=2, metric='precomputed')\n",
        "coordinates_2d = tsne.fit_transform(distance_matrix.values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        },
        "id": "a9gIgVbNJrBW",
        "outputId": "fabbe86e-324b-4881-83d6-e645587820fe"
      },
      "source": [
        "from matplotlib import pyplot as plt\n",
        "\n",
        "\n",
        "# Plotting train representatives and generated sequences with different diversity\n",
        "plt.figure(figsize=(12, 8))\n",
        "plt.scatter(coordinates_2d[:-128,0], coordinates_2d[:-128,1], c=\"green\", label=\"Train representative sequences\", alpha=0.5, s=30)\n",
        "small_var_el = distance_matrix.index.str.contains(\"small_var\")\n",
        "plt.scatter(coordinates_2d[small_var_el,0], coordinates_2d[small_var_el,1], c=\"orange\", label=\"Generated sequences with 0.1 standard deviation\")\n",
        "large_var_el = distance_matrix.index.str.contains(\"large_var\")\n",
        "plt.scatter(coordinates_2d[large_var_el,0], coordinates_2d[large_var_el,1], c=\"red\", label=\"Generated sequences with 1.0 standard deviation \")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nSFhBtY3NhQR"
      },
      "source": [
        "As expected, oranges sequences are more similar to each other than the red ones. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y62ZHV1SUqYA"
      },
      "source": [
        "### Controlling biological properties\n",
        "\n",
        "After generating realistic sequences, you want to be able to control their properties. As with images, it's possible to find a direction in the latent space that will change a specific property of the generated outcome. Here, you can vary values of the 100th dimension and measure the molecular weight of generated sequences. You'll use the [biopython](https://biopython.org/) library to calculate the molecule's weight. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i3osQT59e-JT"
      },
      "source": [
        "from scipy.stats import pearsonr\n",
        "from Bio.SeqUtils.ProtParam import ProteinAnalysis\n",
        "\n",
        "# Changing the values of 100th dimension from -1.0 to 1.0\n",
        "d = 99 \n",
        "starting = np.zeros([128])\n",
        "starting[d] = -1.0\n",
        "ending = np.zeros([128])\n",
        "ending[d] = 1.0\n",
        "points = interpolate(starting, ending, 1023)\n",
        "\n",
        "seqs = []\n",
        "for i in range(0, 1024, 64):\n",
        "  model_output = model(tf.constant(points[i:i+64], tf.float32))\n",
        "  seqs.extend(to_seqs(model_output))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dNvRNj2vVTFh"
      },
      "source": [
        "Then, you can calculate the molecular weight of each sequence and calculate the correlation with latent space direction."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mmxAP-WwUZ8q",
        "outputId": "e7803654-673c-44c6-d40b-fb8a2f3cdf9e"
      },
      "source": [
        "w = [ProteinAnalysis(s).molecular_weight() for s in seqs] \n",
        "pearsonr(w, points[:,d])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.8257028800121902, 2.3451257824258473e-256)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 502
        },
        "id": "JHeiy1y9hFfp",
        "outputId": "d898af5d-2f2d-4c79-d5ac-fb4e6686d5ae"
      },
      "source": [
        "plt.figure(figsize=(16, 8))\n",
        "plt.scatter(points[:,d], w, c = 'b', s = 20, label = 'Molecule weight')\n",
        "plt.xlabel(\"Latent dimension value\", fontsize = 15)\n",
        "plt.ylabel(\"Molecular weight\", fontsize = 15)\n",
        "plt.legend(fontsize = 14)\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "937OnQVxVjKh"
      },
      "source": [
        "Of course, this is a very simplistic example; it is a good illustrative example of how latent space can be explored.\n",
        "\n",
        "\n",
        "## Summary\n",
        "\n",
        "In summary, you have learned about:\n",
        "\n",
        "* Proteins as non-random sequences of 20 amino acids (aa) that nature has tweaked over billions of years of evolution to drive essential life processes;\n",
        "\n",
        "*  ProteinGAN and its technical features outlining the challenges of learning long-biological sequences such as proteins;\n",
        "\n",
        "* Generating random protein sequences from a family of cytidine deaminases using a generator from a pre-trained ProteinGAN model;\n",
        "\n",
        "* Visualizing biological sequences using sequence alignments and dimensionality reduction;\n",
        "\n",
        "* Exploring latent space dimensions and connecting it with physicochemical properties of generated proteins.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_kH5E53bgFGC"
      },
      "source": [
        "## Author's Contribution\n",
        "\n",
        "[Donatas Repečka](https://www.linkedin.com/in/donatasrep/) (Biomatter Designs) was responsible for the notebook's content and design; \n",
        "\n",
        "[Aleksej Zelezniak](https://twitter.com/AZelezniak)  (Zelezniak lab at Chalmers University of Technology) gave input into summarizing and editing the text.\n",
        "\n",
        "## Acknowledgment\n",
        "The authors would like to thank [Biomatter Designs](https://www.biomatterdesigns.com/) and [DeepLearning.AI](https://www.deeplearning.ai/) teams for their comments and insightful suggestions:\n",
        "\n",
        "* [Vykintas Jauniškis](https://www.linkedin.com/in/vykintas-jauniskis/) (Biomatter Designs);\n",
        "* [Laurynas Karpus](https://www.linkedin.com/in/laurynaskarpus/) (Biomatter Designs);\n",
        "* [Audrius Laurynėnas](https://www.linkedin.com/in/audrius-lauryn%C4%97nas-307687b2/) (Biomatter Designs);\n",
        "* [Aurimas Repečka](https://www.linkedin.com/in/aurimas-repe%C4%8Dka-23064ab2/) (Biomatter Designs);\n",
        "* [Irmantas Rokaitis](https://www.linkedin.com/in/irmantas-rokaitis-52336b18b/) (Biomatter Designs);\n",
        "* [Audronė Valančiūtė](https://www.linkedin.com/in/audron%C4%97-valan%C4%8Di%C5%ABt%C4%97-730785158/) (Biomatter Designs);\n",
        "* [Antanas Žilakauskis](https://www.linkedin.com/in/zilakauskis95/) (Biomatter Designs).\n"
      ]
    }
  ]
}