FunC_ESMs.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AcjxZ9mXikrK"
      },
      "source": [
        "# <b><font color='#009e74'>Functional Characterisation via Evolutionary Scale Models (FunC-ESMs) - prediction notebook </font></b>\n",
        "\n",
        "Generation of FunC-ESMs molecular mechanism predictions for variants and labels for the relevance of the structure and function of residues using deep learning representations of Evolutionary Scale Models (ESMs).\n",
        "<br>\n",
        "\n",
        "<p> A Colaboratory implementation of <b> Cagiada.M &#10013, Jonsson N. &#10013, Lindorff-Larsen K., </b> - <a href=https://doi.org/\"> Decoding molecular mechanisms for loss of function variants in the human proteome</a>\n",
        ". Source code is available on the project <a href=hhttps://github.com/KULL-Centre/_2022_functional-sites-cagiada\">Github</a> page.\n",
        "</p>\n",
        "\n",
        "<p> &#10013 : equal contributions from the authors </p>\n",
        "\n",
        "<br>\n",
        "\n",
        "The notebook used as input:\n",
        "- a query protein <b><font color='#009e74'>sequence</font></b>;\n",
        "- an <b><font color='#009e74'>AlphaFold2 structure prediction</font></b> of the query protein (downloaded from AF2 database or uploaded by the user - PDB format);\n",
        "\n",
        "The output files generated include ESM-1B and ESM-IF marginal score predictions, FunC-ESMs predictions for the mechanism of variants and the biochemical role of residues.\n",
        "The predictions can be downloaded in CSV or Excel format.\n",
        "\n",
        "\\\\\n",
        "\n",
        "****\n",
        "\\\\\n",
        "\n",
        "### <b>PRACTICALITIES</b>\n",
        "\n",
        "- This notebook <b><font color='#d55c00'>must be</font></b> running in a Colab GPU session (go to the top menu tab: `Runtime`->  `Change runtime type` -> select `GPU` and confirm.\n",
        "\n",
        "- Cells labelled <b><font color='#f0e422'>PRELIMINARY OPERATIONS </font></b>  must be run <b><font color='#d55c00'>ONE TIME</font></b>  at the start and <b>SKIPPED</b> for new predictions.\n",
        "\n",
        "- Multiple predictions can be run in a single session by uploading the data for a new query protein in the cell: <b><font color='#56b4e9'> DATA UPLOADING</font></b>.\n",
        "\n",
        "- For structural stability evaluations with ESM-IF, the **input structure** can have <b><font color='#d55c00'>one</font></b> or <b><font color='#d55c00'>multiple</font></b> chains. A **target** chain must be selected, while the remaining chains, if present, can be excluded or retained (to assess stability in a complex). The presence or absence of the remaining chains **WILL INFLUENCE** the stability predictions and thus the classification.\n",
        "\n",
        "- The input <b><font color='#d55c00'>query</font></b>  and <b><font color='#d55c00'>structure</font></b> sequences <b><font color='#d55c00'>MUST MATCH</font></b>.\n",
        "\n",
        "- If you wish to download the predictions you can find them in the <b>/content/FunC-ESMs_outputs</b> folder, if you wish to download <b>ALL</b>  the prediction as zip file run the last cell called <b><font color='#56b4e9'>DOWNLOAD RESULTS </font>\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title <b><font color='#f0e422'>PRELIMINARY OPERATIONS:</font> Install condalab\n",
        "#@markdown Run the cell to install conda-colab, now (from Oct 2024) required for torch dependencies <b>(walltime ~1 min)</b>\n",
        "!pip install -q condacolab\n",
        "\n",
        "import condacolab\n",
        "condacolab.install()"
      ],
      "metadata": {
        "id": "hAPahDq4hHuB",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nAPBZ3Jcha08",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "#@title <b><font color='#f0e422'>PRELIMINARY OPERATIONS:</font> Install dependencies\n",
        "\n",
        "#@markdown Run the cell to downaload and install all the extra necessaries packages <b>(walltime ~10/15 mins)</b>, including:\n",
        "#@markdown - ESM-IF, ESM-1B (libraries and parameters)\n",
        "#@markdown - Torch libraries: torch-scatter,-sparse,-cluster,spline-conv,-geometric\n",
        "#@markdown - Python libraries: biopython, biotite, PrismParser\n",
        "\n",
        "%%time\n",
        "import os,time,subprocess,re,sys,shutil\n",
        "from google.colab import files\n",
        "import torch\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import gc\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def format_pytorch_version(version):\n",
        "  return version.split('+')[0]\n",
        "\n",
        "def format_cuda_version(version):\n",
        "  return 'cu' + version.replace('.', '')\n",
        "\n",
        "TORCH_version = torch.__version__\n",
        "TORCH = format_pytorch_version(TORCH_version)\n",
        "CUDA_version = torch.version.cuda\n",
        "CUDA = format_cuda_version(CUDA_version)\n",
        "ESMIF_model_name = \"esm_if1_gvp4_t16_142M_UR50.pt\"\n",
        "ESM1B_model_name = \"esm1b_t33_650M_UR50S.pt\"\n",
        "ESM1B_model_contact = \"esm1b_t33_650M_UR50S-contact-regression.pt\"\n",
        "\n",
        "os.system(\"apt-get install aria2 -qq\")\n",
        "if not os.path.isfile(ESMIF_model_name) or not os.path.isfile(ESM1B_model_name):\n",
        "\n",
        "  # download esmfold params\n",
        "  print(\"installing downloading ESM-1b parameters... (in background)\")\n",
        "  os.system(f\"aria2c -x 16 https://sid.erda.dk/share_redirect/hcoUfJRcgG --out={ESM1B_model_contact} &\")\n",
        "  os.system(f\"aria2c -x 16 https://sid.erda.dk/share_redirect/DKJpFWiwkf --out={ESM1B_model_name} &\")\n",
        "\n",
        "  if not os.path.isfile(\"finished_install\"):\n",
        "    # install libs\n",
        "    print(\"installing libs...\")\n",
        "    os.system(f\"conda install conda-forge::torch-scatter\")\n",
        "    os.system(f\"conda install conda-forge::pytorch_sparse\")\n",
        "    os.system(f\"conda install conda-forge::torch-cluster\")\n",
        "    os.system(f\"conda install ostrokach-forge::torch-spline-conv\")\n",
        "    os.system(f\"conda install pyg -c pyg\")\n",
        "    print('...finished torch dependencies')\n",
        "    os.system(f\"pip install biopython\")\n",
        "    os.system(f\"pip install biotite\")\n",
        "    os.system(f\"pip install alive-progress\")\n",
        "    print('...finish extras')\n",
        "\n",
        "    # import prismparser\n",
        "    !git clone https://github.com/KULL-Centre/PrismData.git\n",
        "    !mv /content/PrismData/PrismData.py /content/PrismData.py\n",
        "    !rm -r /content/PrismData\n",
        "\n",
        "    print(\"installing esmfold...\")\n",
        "    # install esmfold\n",
        "    os.system(f\"pip install git+https://github.com/matteo-cagiada/esm.git\")\n",
        "    os.system(\"touch finished_install\")\n",
        "\n",
        "    #wait for Params to finish downloading...\n",
        "    while not os.path.isfile(ESM1B_model_name):\n",
        "      time.sleep(5)\n",
        "    if os.path.isfile(f\"{ESM1B_model_name}.aria2\"):\n",
        "      print(\"finishing downloading parameters ESM-1b...\")\n",
        "    while os.path.isfile(f\"{ESM1B_model_name}.aria2\"):\n",
        "      time.sleep(5)\n",
        "\n",
        "  # download esmfold params\n",
        "  print(\"installing downloading ESM-IF parameters...\")\n",
        "\n",
        "  os.system(f\"aria2c -x 16 https://sid.erda.dk/share_redirect/eIZVVNEd8B --out={ESMIF_model_name}\")\n",
        "\n",
        "from PrismData import PrismParser\n",
        "from alive_progress import alive_bar\n",
        "\n",
        "## Verify that pytorch-geometric is correctly installed\n",
        "\n",
        "import esm\n",
        "\n",
        "from esm.inverse_folding.util import load_structure, extract_coords_from_structure,CoordBatchConverter\n",
        "from esm.inverse_folding.multichain_util import extract_coords_from_complex,_concatenate_coords,load_complex_coords\n",
        "\n",
        "print(\"--> Installations succeeded\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "f5ceGDKztFZp"
      },
      "outputs": [],
      "source": [
        "#@title <b><font color='#f0e422'>PRELIMINARY OPERATIONS:</font> Load EXTRA functions\n",
        "#@markdown Run the cell to load the required dictionaries and functions\n",
        "\n",
        "alphabetAA_L_D_reordered={0:'R',1:'H',2:'K',3:'D',4:'E',5:'S',6:'T',7:'N',8:'Q',9:'C',10:'G',11:'P',12:'A',13:'V',14:'I',15:'L',16:'M',17:'F',18:'Y',19:'W'}\n",
        "alphabetAA_D_D_reordered={14:0,6:1,8:2,2:3,3:4,15:5,16:6,11:7,13:8,1:9,5:10,12:11,0:12,17:13,7:14,9:15,10:16,4:17,19:18,18:19}\n",
        "alphabetAA_L_D={'-':0,'_' :0,'A':1,'C':2,'D':3,'E':4,'F':5,'G':6,'H':7,'I':8,'K':9,'L':10,'M':11,'N':12,'P':13,'Q':14,'R':15,'S':16,'T':17,'V':18,'W':19,'Y':20}\n",
        "alphabetAA_D_L={v: k for k, v in alphabetAA_L_D.items()}\n",
        "alphabet_class_variant_d_l={0:'WT-like',1:'Stable-but-inactive',2:'Total-loss'}\n",
        "alphabet_class_residue_d_l={0:'Tolerant',1:'Functionally-relevant',2:'Structurally-critical',4:'Mixed'}\n",
        "\n",
        "def ESM1B_pred(model,alphabet,sequence=None):\n",
        "\n",
        "  print('--> running ESM1b')\n",
        "\n",
        "  logits=run_1B(sequence,model,alphabet)\n",
        "\n",
        "  mutation_list,outscores=scores_variants(sequence,logits,alphabet)\n",
        "\n",
        "  print('<-- ESM1b run completed')\n",
        "\n",
        "  return mutation_list,outscores\n",
        "\n",
        "def ESMIF_pred(model,alphabet,sequence=None,coords=None,cmplx=None,chain_targer=None):\n",
        "\n",
        "  print('--> running ESM-IF')\n",
        "\n",
        "  logits=run_IF(coords,sequence,model,alphabet,cmplx=is_complex,chain_target=chain_id)\n",
        "\n",
        "  mutation_list,outscores=scores_variants(sequence,logits,alphabet)\n",
        "\n",
        "  print('<-- ESM-IF run completed')\n",
        "\n",
        "  return mutation_list,outscores\n",
        "\n",
        "def run_IF(coords,sequence,model,alphabet,cmplx=False,chain_target='A'):\n",
        "\n",
        "  device = next(model.parameters()).device\n",
        "\n",
        "  batch_converter = CoordBatchConverter(alphabet)\n",
        "  batch = [(coords, None, sequence)]\n",
        "  coords, confidence, strs, tokens, padding_mask = batch_converter(\n",
        "      batch, device=device)\n",
        "\n",
        "  prev_output_tokens = tokens[:, :-1].to(device)\n",
        "  target = tokens[:, 1:]\n",
        "  target_padding_mask = (target == alphabet.padding_idx)\n",
        "\n",
        "  logits, _ = model.forward(coords, padding_mask, confidence, prev_output_tokens)\n",
        "\n",
        "  logits_swapped=torch.swapaxes(logits,1,2)\n",
        "  token_probs = torch.log_softmax(logits_swapped, dim=-1)\n",
        "\n",
        "  return token_probs[0,:,:]\n",
        "\n",
        "def run_1B(sequence,model,alphabet):\n",
        "  batch_converter = alphabet.get_batch_converter()\n",
        "\n",
        "  data = [\n",
        "      (\"protein1\", sequence),\n",
        "  ]\n",
        "  batch_labels, batch_strs, batch_tokens = batch_converter(data)\n",
        "\n",
        "  all_token_probs = []\n",
        "  with alive_bar(batch_tokens.size(1),force_tty=True,spinner='squares',bar='bubbles') as bar:\n",
        "\n",
        "    for i in range(batch_tokens.size(1)):\n",
        "        bar()\n",
        "        batch_tokens_masked = batch_tokens.clone()\n",
        "        batch_tokens_masked[0, i] = alphabet.mask_idx\n",
        "\n",
        "        logits=model(batch_tokens_masked.cuda())[\"logits\"]\n",
        "        token_probs = torch.log_softmax(logits, dim=-1)\n",
        "\n",
        "        all_token_probs.append(token_probs[:, i])  # vocab size\n",
        "\n",
        "  token_probs = torch.cat(all_token_probs, dim=0).unsqueeze(0)\n",
        "\n",
        "  return token_probs[0,1:,:]\n",
        "\n",
        "def scores_variants(sequence,token_probs,alphabet):\n",
        "\n",
        "  mutation_list=[]\n",
        "  outscores=np.empty((len(sequence),20),dtype=float)\n",
        "  outscores[:]=np.nan\n",
        "\n",
        "  for i,n in enumerate(sequence):\n",
        "      for j in range(1,21):\n",
        "          if alphabetAA_D_L[j]!=n:\n",
        "              mutation_list.append(n+str(i+1)+alphabetAA_D_L[j])\n",
        "              outscores[i,j-1]=masked_marginals(mutation_list[-1],sequence, token_probs, alphabet)\n",
        "          else:\n",
        "              mutation_list.append(n+str(i+1)+\"=\")\n",
        "              outscores[i,j-1]=0.\n",
        "\n",
        "  return mutation_list, outscores\n",
        "\n",
        "def masked_marginals(mut, sequence, token_probs, alphabet):\n",
        "  wt, idx, mt = mut[0], int(mut[1:-1]) - 1, mut[-1]\n",
        "  assert sequence[idx] == wt, \"The listed wildtype does not match the provided sequence\"\n",
        "\n",
        "  wt_encoded, mt_encoded = alphabet.get_idx(wt), alphabet.get_idx(mt)\n",
        "\n",
        "  score = token_probs[idx, mt_encoded] - token_probs[idx, wt_encoded]\n",
        "  return score.item()\n",
        "\n",
        "def classify_variants(esm1b_scores,esmif_scores,esm1b_threshold=-6.5,esmif_threshold=-7.0):\n",
        "\n",
        "  print('--> FunC-ESMs classification ...')\n",
        "\n",
        "  variant_class=np.zeros((esm1b_scores.shape[0],esm1b_scores.shape[1]),dtype=float)\n",
        "  for i in range(esm1b_scores.shape[0]):\n",
        "    for j in range(esm1b_scores.shape[1]):\n",
        "\n",
        "      if esm1b_scores[i,j] < esm1b_threshold:\n",
        "          if esmif_scores[i,j] < esmif_threshold:\n",
        "              variant_class[i,j]=2\n",
        "          else:\n",
        "              variant_class[i,j]=1\n",
        "\n",
        "  return variant_class\n",
        "\n",
        "def classify_residues(variant_class_matrix):\n",
        "  res_class=np.empty(variant_class_matrix.shape[0],dtype=float)\n",
        "  res_class[:]=np.nan\n",
        "\n",
        "  for i in range(variant_class_matrix.shape[0]):\n",
        "      res_class[i]=retrieve_res_class(variant_class_matrix[i,:])\n",
        "\n",
        "  print('<-- FunC-ESMs classification completed')\n",
        "  return res_class\n",
        "\n",
        "def retrieve_res_class(variants_class):\n",
        "  unique_values, counts = np.unique(variants_class, return_counts=True)\n",
        "  if np.any(counts/np.sum(counts) >0.5):\n",
        "      return unique_values[np.argmax(counts)]\n",
        "  else:\n",
        "      return 4.\n",
        "  return res_class\n",
        "\n",
        "\n",
        "def heatmap_values_reordered(ext_score,label_cm,WT_mask,x,title_figure='',where_save='./',figs=[30,7],xtick_spacing=10,colour_map='RdBu',min_colour=-15):\n",
        "    mpl.rcParams['xtick.labelsize'] = 18\n",
        "    mpl.rcParams['ytick.labelsize'] = 18\n",
        "    mpl.rcParams['axes.labelsize']  = 20\n",
        "\n",
        "    score=np.copy(ext_score)\n",
        "\n",
        "    for i in range(score.shape[1]):\n",
        "        #print(i,score[:,i][0:10])\n",
        "        score[:,alphabetAA_D_D_reordered[i]]=ext_score[:,i]\n",
        "        #print(alphabetAA_D_D_reordered[i],score[:,alphabetAA_D_D_reordered[i]][0:10])\n",
        "\n",
        "    score_nan=np.copy(ext_score)\n",
        "    score_nan[:]=np.inf\n",
        "\n",
        "    for i in range(score.shape[0]):\n",
        "        for j in range(score.shape[1]):\n",
        "                if np.isnan(ext_score[i,j])==True and WT_mask[i]!=alphabetAA_D_L[j+1]:\n",
        "\n",
        "                    score_nan[i,alphabetAA_D_D_reordered[j]]=1\n",
        "                    #print(WT_mask[i],alphabetAA_D_D_reordered[alphabetAA_D_L[j+1]])\n",
        "\n",
        "    fig, ax = plt.subplots(figsize=(figs[0],figs[1]),layout='tight')\n",
        "    ylabels=[ alphabetAA_L_D_reordered[i] for i in range(0,20)]\n",
        "\n",
        "    pos=ax.imshow(np.transpose(score), aspect = 'auto', cmap=f'{colour_map}_r',vmin=min_colour, vmax=0, interpolation='nearest')\n",
        "    fig.colorbar(pos, label=label_cm)\n",
        "\n",
        "    #current_cmap = mpl.cm.get_cmap()\n",
        "    current_cmap = plt.get_cmap()\n",
        "    current_cmap.set_bad(color='gray')\n",
        "\n",
        "\n",
        "    ax.set_yticks([i for i in range(0,20)])\n",
        "    ax.set_yticklabels(ylabels)\n",
        "\n",
        "    #ax.xaxis.set_ticks(np.arange(1, end, stepsize))\n",
        "\n",
        "    plt.grid(axis='both',which='both',alpha=0.4)\n",
        "    plt.ylabel(\"Mutation to\")\n",
        "    plt.xlabel(\"residue\")\n",
        "    plt.ylim(-0.5,19.5)\n",
        "    plt.xlim(x[0]-0.5,x[1]+0.5)\n",
        "    start, end = ax.get_xlim()\n",
        "    ax.xaxis.set_ticks(np.arange(start+0.5, end, xtick_spacing))\n",
        "    ax.tick_params(axis='x',rotation=90)\n",
        "    ax.tick_params(axis='y',rotation=90)\n",
        "    ax.set_title(title_figure,fontsize=20)\n",
        "    tmp=np.empty((len(WT_mask),20),dtype=float)\n",
        "    tmp[:]=np.inf\n",
        "    for i in range(0,len(WT_mask)):\n",
        "        tmp[i,alphabetAA_D_D_reordered[alphabetAA_L_D[WT_mask[i]]-1]]=1\n",
        "\n",
        "    plt.imshow(score_nan.T, cmap='Dark2_r', aspect = 'auto',interpolation='nearest')\n",
        "    plt.imshow(tmp.T, cmap='gnuplot_r', aspect = 'auto',interpolation='nearest')\n",
        "    plt.savefig(os.path.join(where_save,title_figure+'_variant_map.pdf'),dpi=300,bbox_inches='tight')\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def heatmap_classes_reordered(ext_score,label_cm,WT_mask,x,title_figure='',where_save='./',WT_cmap='gnuplot_r',nan_cmap='Dark2_r',figs=[30,7],xtick_spacing=10):\n",
        "\n",
        "  mpl.rcParams['xtick.labelsize'] = 18\n",
        "  mpl.rcParams['ytick.labelsize'] = 18\n",
        "  mpl.rcParams['axes.labelsize']  = 20\n",
        "\n",
        "  score=np.copy(ext_score)\n",
        "\n",
        "  for i in range(score.shape[1]):\n",
        "      #print(i,score[:,i][0:10])\n",
        "      score[:,alphabetAA_D_D_reordered[i]]=ext_score[:,i]\n",
        "      #print(alphabetAA_D_D_reordered[i],score[:,alphabetAA_D_D_reordered[i]][0:10])\n",
        "\n",
        "  score_nan=np.copy(ext_score)\n",
        "  score_nan[:]=np.inf\n",
        "\n",
        "  for i in range(score.shape[0]):\n",
        "      for j in range(score.shape[1]):\n",
        "              if np.isnan(ext_score[i,j])==True and WT_mask[i]!=alphabetAA_D_L[j+1]:\n",
        "\n",
        "                  score_nan[i,alphabetAA_D_D_reordered[j]]=1\n",
        "                  #print(WT_mask[i],alphabetAA_D_D_reordered[alphabetAA_D_L[j+1]])\n",
        "\n",
        "  fig, ax = plt.subplots(figsize=(figs[0],figs[1]),layout='tight')\n",
        "  ylabels=[ alphabetAA_L_D_reordered[i] for i in range(0,20)]\n",
        "  if np.isnan(np.unique(score)).any():\n",
        "    num_colors=len(np.unique(score))-1\n",
        "  else:\n",
        "    num_colors=len(np.unique(score))\n",
        "\n",
        "  if num_colors==3:\n",
        "    pos=ax.imshow(np.transpose(score), aspect = 'auto', cmap=mpl.colors.ListedColormap([\"#009e74\", \"#56b4e9\",\"#d55c00\"]),interpolation='nearest')\n",
        "  elif num_colors==4:\n",
        "    pos=ax.imshow(np.transpose(score), aspect = 'auto', cmap=mpl.colors.ListedColormap([\"#009e74\", \"#56b4e9\",\"#d55c00\",\"#f0e442\"]),interpolation='nearest')\n",
        "\n",
        "  #current_cmap = mpl.cm.get_cmap()\n",
        "  current_cmap = plt.get_cmap()\n",
        "  current_cmap.set_bad(color='gray')\n",
        "\n",
        "  ax.set_yticks([i for i in range(0,20)])\n",
        "  ax.set_yticklabels(ylabels)\n",
        "\n",
        "  #ax.xaxis.set_ticks(np.arange(1, end, stepsize))\n",
        "\n",
        "  plt.grid(axis='both',which='both',alpha=0.4)\n",
        "  #plt.ylabel(\"mutation\")\n",
        "  plt.xlabel(\"residue\")\n",
        "  plt.ylim(-0.5,19.5)\n",
        "  plt.xlim(x[0]-0.5,x[1]+0.5)\n",
        "  start, end = ax.get_xlim()\n",
        "  ax.xaxis.set_ticks(np.arange(start+0.5, end, xtick_spacing))\n",
        "  ax.tick_params(axis='x',rotation=90)\n",
        "  ax.tick_params(axis='y',rotation=90)\n",
        "  ax.set_title(title_figure,fontsize=20)\n",
        "  tmp=np.empty((len(WT_mask),20),dtype=float)\n",
        "  tmp[:]=np.inf\n",
        "  for i in range(0,len(WT_mask)):\n",
        "      tmp[i,alphabetAA_D_D_reordered[alphabetAA_L_D[WT_mask[i]]-1]]=1\n",
        "\n",
        "  plt.imshow(score_nan.T, cmap=nan_cmap, aspect = 'auto',interpolation='nearest')\n",
        "  plt.imshow(tmp.T, cmap=WT_cmap, aspect = 'auto',interpolation='nearest')\n",
        "  plt.savefig(os.path.join(where_save,title_figure+'_variant_map.pdf'),dpi=300,bbox_inches='tight')\n",
        "  plt.show()\n",
        "\n",
        "def residues_classes_reordered(ext_score,x,title_figure='',where_save='./',figs=[20,1],xtick_spacing=10):\n",
        "  mpl.rcParams['xtick.labelsize'] = 18\n",
        "  mpl.rcParams['ytick.labelsize'] = 18\n",
        "  mpl.rcParams['axes.labelsize']  = 20\n",
        "  fig,ax1 = plt.subplots(1,1,figsize=(figs[0],figs[1]),layout='tight')\n",
        "\n",
        "  if 4. in ext_score:\n",
        "    ax1.imshow(ext_score.reshape(1,-1),aspect= 'auto', cmap=mpl.colors.ListedColormap([\"#009e74\", \"#56b4e9\",\"#d55c00\",\"#5A5A5A\",\"#5A5A5A\"]))\n",
        "  else:\n",
        "      ax1.imshow(ext_score.reshape(1,-1),aspect= 'auto', cmap=mpl.colors.ListedColormap([\"#009e74\", \"#56b4e9\",\"#d55c00\"]))\n",
        "\n",
        "  ax1.set_yticks([])\n",
        "  plt.xlim(x[0]-0.5,x[1]+0.5)\n",
        "\n",
        "  start, end = ax1.get_xlim()\n",
        "  ax1.xaxis.set_ticks(np.arange(start+0.5, end, xtick_spacing))\n",
        "  ax1.tick_params(axis='x',rotation=90)\n",
        "\n",
        "  ax1.set_xlabel('residue')\n",
        "  ax1.set_title(title_figure,fontsize=20)\n",
        "  plt.savefig(os.path.join(where_save,title_figure+'_residue_class.pdf'),dpi=300,bbox_inches='tight')\n",
        "  plt.show()\n",
        "\n",
        "def histogram_data(data_input,range_data,xlabel,title,where_save,sequence=None,wt_score=0.):\n",
        "  if not sequence is None:\n",
        "    for idx,wtaa in enumerate(sequence):\n",
        "      data_input[idx,alphabetAA_L_D[wtaa]-1]=np.nan\n",
        "\n",
        "  fig,ax=plt.subplots(1,1,figsize=(6,4),layout='tight')\n",
        "  ax.hist(data_input.flatten(),range=range_data,bins=20,edgecolor='k',facecolor='#56b4e9')\n",
        "  y_lim=ax.get_ylim()\n",
        "\n",
        "  ax.plot([wt_score,y_lim[0]],[wt_score,y_lim[1]],'k--',lw=2.,label='WT-score')\n",
        "  ax.set_ylim(y_lim[0],y_lim[1])\n",
        "  ax.set_xlabel(xlabel)\n",
        "  ax.set_ylabel('counts')\n",
        "  ax.set_title(title)\n",
        "  ax.legend()\n",
        "  plt.savefig(os.path.join(where_save,title+'_histogram.pdf'),dpi=300,bbox_inches='tight')\n",
        "\n",
        "  plt.show()\n",
        "\n",
        "def count_class_variant_position(variant_matrix,pred_class):\n",
        "\n",
        "  variant_class_count=[]\n",
        "  for i in range(variant_matrix.shape[0]):\n",
        "    variant_class_count.append(np.count_nonzero((variant_matrix[i,:]==pred_class)))\n",
        "\n",
        "  return np.array(variant_class_count)\n",
        "\n",
        "print('<-- functions loaded')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "a1PLKPT6rya-"
      },
      "outputs": [],
      "source": [
        "#@title <b><font color='#f0e422'>PRELIMINARY OPERATIONS:</font> Load ESM1B and ESM-IF in the GPU\n",
        "#@markdown RUN this cell to load the models into the GPUs.\n",
        "\n",
        "#@markdown **N.B.: RUN THIS CELL ONCE ( a second execution will make the THE SESSION CRASH )**\n",
        "model_IF, alphabet_IF = esm.pretrained.load_model_and_alphabet(ESMIF_model_name)\n",
        "model_IF.eval().cuda().requires_grad_(False)\n",
        "\n",
        "model_1B, alphabet_1B = esm.pretrained.load_model_and_alphabet(ESM1B_model_name)\n",
        "model_1B.eval().cuda().requires_grad_(False)\n",
        "\n",
        "print('<-- models loaded!')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "fbmpNhrvbKil"
      },
      "outputs": [],
      "source": [
        "#@title <b><font color='#56b4e9'> DATA UPLOADING</font>\n",
        "#@markdown Fill in the fields to set the parameters for the run and upload target sequence and structure. Then run the cell to set up the system for the evaluation.\n",
        "#@markdown ****\n",
        "\n",
        "#@markdown <br>\n",
        "\n",
        "\n",
        "jobname='P30825'#@param {type:\"string\"}\n",
        "\n",
        "## print files:\n",
        "#@markdown Select the output format for the result files:\n",
        "output_format = \"csv\" #@param [\"csv\",\"excel\"]\n",
        "#@markdown <br>\n",
        "\n",
        "#@markdown Insert the target sequence:\n",
        "query_sequence='MGCKVLLNIGQQMLRRKVVDCSREETRLSRCLNTFDLVALGVGSTLGAGVYVLAGAVARENAGPAIVISFLIAALASVLAGLCYGEFGARVPKTGSAYLYSYVTVGELWAFITGWNLILSYIIGTSSVARAWSATFDELIGRPIGEFSRTHMTLNAPGVLAENPDIFAVIIILILTGLLTLGVKESAMVNKIFTCINVLVLGFIMVSGFVKGSVKNWQLTEEDFGNTSGRLCLNNDTKEGKPGVGGFMPFGFSGVLSGAATCFYAFVGFDCIATTGEEVKNPQKAIPVGIVASLLICFIAYFGVSAALTLMMPYFCLDNNSPLPDAFKHVGWEGAKYAVAVGSLCALSASLLGSMFPMPRVIYAMAEDGLLFKFLANVNDRTKTPIIATLASGAVAAVMAFLFDLKDLVDLMSIGTLLAYSLVAACVLVLRYQPEQPNLVYQMASTSDELDPADQNELASTNDSQLGFLPEAEMFSLKTILSPKNMEPSKISGLIVNISTSLIAVLIITFCIVTVLGREALTKGALWAVFLLAGSALLCAVVTGVIWRQPESKTKLSFKVPFLPVLPILSIFVNVYLMMQLDQGTWVRFAVWMLIGFIIYFGYGLWHSEEASLDADQARTPDGNLDQCK' #@param {type:'string'}\n",
        "\n",
        "#@markdown <br>\n",
        "\n",
        "#@markdown Choose between <b><font color='#d55c00'> ONE</font></b> of the possible input sources for the target pdb and <b><font color='#d55c00'>leave the other cells empty or unmarked</font></b>\n",
        "\n",
        "#@markdown - Download AlphaFold2 PDB (v4) via Uniprot ID:\n",
        "AF_ID ='P30825'#@param {type:\"string\"}\n",
        "\n",
        "#@markdown - Upload custom PDB\n",
        "AF_custom =False#@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown Select target chain (default A)\n",
        "chain_id='A' #@param {type:'string'}\n",
        "\n",
        "#@markdown - is the used structure a complex?\n",
        "is_complex=False#@param {type:\"boolean\"}\n",
        "\n",
        "#@markdown - Select target chain (only if **is_complex** is selected)\n",
        "chains_complex='A,B' #@param {type:'string'}\n",
        "chains_complex=chains_complex.split(',')\n",
        "\n",
        "\n",
        "\n",
        "if ' ' in query_sequence:\n",
        "    sys.exit ('!!!! Run interrupted: please check input sequence before proceeding space characters detected!!!!')\n",
        "\n",
        "input_path = f\"/content/inputs\"\n",
        "if not os.path.exists(input_path):\n",
        "  os.mkdir(input_path)\n",
        "\n",
        "outputs_dir = f\"/content/FunC-ESMs_outputs\"\n",
        "if not os.path.exists(outputs_dir):\n",
        "  os.mkdir(outputs_dir)\n",
        "\n",
        "plot_folder=os.path.join(outputs_dir,'figures')\n",
        "if not os.path.exists(plot_folder):\n",
        "  os.mkdir(plot_folder)\n",
        "\n",
        "\n",
        "if AF_custom:\n",
        "  print('Upload PDB file:')\n",
        "  uploaded_AF = files.upload()\n",
        "  for fn in uploaded_AF.keys():\n",
        "    os.rename(fn, f\"/content/inputs/query_protein.pdb\")\n",
        "    output_name_pdb=fn\n",
        "    print('PDB file correctly loaded')\n",
        "elif (AF_ID !='') and (len(AF_ID)>=6) :\n",
        "    subprocess.call(['curl','-s','-f',f'https://alphafold.ebi.ac.uk/files/AF-{AF_ID}-F1-model_v4.pdb','-o','/content/inputs/query_protein.pdb'])\n",
        "    output_name_pdb=f'AF-{AF_ID}-F1-model_v4.pdb'\n",
        "else:\n",
        "  sys.exit(f'ERROR: any PDB uploaded, please select one of the above inputs')\n",
        "\n",
        "if is_complex:\n",
        "\n",
        "  coords_structures, sequences_structure = load_complex_coords(f\"/content/inputs/query_protein.pdb\", chains_complex)\n",
        "  sequence_structure=sequences_structure[chain_id]\n",
        "\n",
        "  coords_structure = _concatenate_coords(coords_structures, chain_id)\n",
        "\n",
        "else:\n",
        "\n",
        "  structure = load_structure(f\"/content/inputs/query_protein.pdb\", chain_id)\n",
        "  coords_structure, sequence_structure = extract_coords_from_structure(structure)\n",
        "\n",
        "assert len(query_sequence) == len(sequence_structure), \"Alternative sequence length doesn't match pdb sequence length, run interrupted!\"\n",
        "\n",
        "print('--> Upload completed wihout errors')\n",
        "\n",
        "\n",
        "#@markdown ****"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "-Oh48Yg0qNMo"
      },
      "outputs": [],
      "source": [
        "#@title <b><font color='#56b4e9'>MODEL RUN:</font> Variants and residues classification\n",
        "#@markdown Run the cell to first run ESM1b and ESM-IF and generate scores for each variant. Then FunC-ESMs will be used to generate predictions for the query protein at variant and residue level.\n",
        "\n",
        "mut_list,outscores_1B=ESM1B_pred(model_1B,alphabet_1B,sequence=query_sequence)\n",
        "\n",
        "histogram_data(outscores_1B,range_data=[-20,5],xlabel='ESM1b scores',title=jobname+'_ESM1b',where_save=plot_folder,sequence=query_sequence)\n",
        "\n",
        "\n",
        "mut_list,outscores_IF=ESMIF_pred(model_IF,alphabet_IF,sequence=sequence_structure,coords=coords_structure,cmplx=is_complex,chain_targer=chain_id)\n",
        "\n",
        "histogram_data(outscores_IF,range_data=[-20,5],xlabel='ESM-IF scores',title=jobname+'_ESM-IF',where_save=plot_folder,sequence=query_sequence)\n",
        "\n",
        "variants_class=classify_variants(outscores_1B,outscores_IF)\n",
        "\n",
        "residues_class=classify_residues(variants_class)\n",
        "\n",
        "### copy PDB, make df and print them in results folder\n",
        "\n",
        "print('--> Saving data ...')\n",
        "shutil.copy(f\"/content/inputs/query_protein.pdb\",f\"FunC-ESMs_outputs/{output_name_pdb}\")\n",
        "\n",
        "df_esm1B=pd.DataFrame({'Mutation': np.array(mut_list).flatten(),\n",
        "                        'ESM1b_scores' : outscores_1B.flatten()})\n",
        "\n",
        "df_esmIF=pd.DataFrame({'Mutation': np.array(mut_list).flatten(),\n",
        "                        'ESM1IF_scores' : outscores_IF.flatten()})\n",
        "\n",
        "df_variants=pd.DataFrame({'Mutation': np.array(mut_list).flatten(),\n",
        "                        'Variant-class ' : np.vectorize(alphabet_class_variant_d_l.get)(variants_class.flatten()),\n",
        "                        'Variant-digit-class' : variants_class.flatten()})\n",
        "res_list=[]\n",
        "for i in range(0,len(query_sequence)):\n",
        "  res_list.append(query_sequence[i]+str(i+1))\n",
        "\n",
        "df_residues=pd.DataFrame({'Residue': np.array(res_list).flatten(),\n",
        "                        'Residue-class ' : np.vectorize(alphabet_class_residue_d_l.get)(residues_class.flatten()),\n",
        "                        'Residue-digit-class' : residues_class.flatten(),\n",
        "                        '#-WT-like-variant' : count_class_variant_position(variants_class,0),\n",
        "                        '#-SBI-variant' : count_class_variant_position(variants_class,1),\n",
        "                        '#-Total-loss-variant' : count_class_variant_position(variants_class,2)})\n",
        "\n",
        "if output_format== 'csv':\n",
        "  df_esm1B.to_csv(f\"FunC-ESMs_outputs/\"+f\"{jobname}_ESM1B_scores.csv\",sep=',')\n",
        "  df_esmIF.to_csv(f\"FunC-ESMs_outputs/\"+f\"{jobname}_ESMIF_scores.csv\",sep=',')\n",
        "  df_variants.to_csv(f\"FunC-ESMs_outputs/\"+f\"{jobname}_FunC-ESMs_variants_pred.csv\",sep=',')\n",
        "  df_residues.to_csv(f\"FunC-ESMs_outputs/\"+f\"{jobname}_FunC-ESMs_residues_pred.csv\",sep=',')\n",
        "\n",
        "if output_format== 'excel':\n",
        "  df_esm1B.to_excel(f\"FunC-ESMs_outputs/\"+f\"{jobname}_ESM1B_scores.xlsx\")\n",
        "  df_esmIF.to_excel(f\"FunC-ESMs_outputs/\"+f\"{jobname}_ESMIF_scores.xlsx\")\n",
        "  df_variants.to_excel(f\"FunC-ESMs_outputs/\"+f\"{jobname}_FunC-ESMs_variants_pred.xlsx\")\n",
        "  df_residues.to_excel(f\"FunC-ESMs_outputs/\"+f\"{jobname}_FunC-ESMs_residues_pred.xlsx\")\n",
        "\n",
        "print('--> Data saved in FunC-ESMs_output folder')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KlDuWfNne-Vh"
      },
      "source": [
        "## <b><font color='#56b4e9'>Visualise the results: </font>\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "vz1ntA-seimH"
      },
      "outputs": [],
      "source": [
        "#@title <b>Conservation score (ESM-1b)</b>\n",
        "#@markdown Visualise the ESM-1b variant score heatmap for the query sequence\\\n",
        "#@markdown \\\n",
        "#@markdown **Color keys:**\n",
        "#@markdown - Light shade variants: non-detrimental / Dark shade variants : detrimental\n",
        "#@markdown - <b><font color='grey'>Grey </font></b>: Missing positions\n",
        "#@markdown - <b><font color='#F0E442'>YELLOW </font></b>: WT amino acid\n",
        "\n",
        "#@markdown Changing the min_colormap value (suggested from -5 to -30) will make the heatmap closer to binary (~5) or more detailed (<<-5).\n",
        "\n",
        "#@markdown **N.B.:** residue numeration in the figure starts from 0 (remember to add +1 for original residue numeration).\n",
        "\n",
        "plot_width=50 #@param\n",
        "\n",
        "min_colormap=-15 #@param\n",
        "\n",
        "colour_map='Greens' #@param [\"Blues\", \"Greens\",\"Purples\"]\n",
        "\n",
        "heatmap_values_reordered(outscores_1B,'ESM-1B score',query_sequence,[0,len(query_sequence)-1],xtick_spacing=20,figs=[plot_width,6],where_save=plot_folder,title_figure=jobname+'_conservation',colour_map=colour_map,min_colour=min_colormap)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "FY578RtDfbZb"
      },
      "outputs": [],
      "source": [
        "#@title <b> Stability changes score (ESM-IF)</b>\n",
        "#@markdown Visualise the ESM-IF variant score heatmap for the uploaded query structure\\\n",
        "#@markdown \\\n",
        "#@markdown **Color keys:**\n",
        "#@markdown - Light shade variants: stable / Dark shade variants : unstable\n",
        "#@markdown - <b><font color='grey'>Grey </font></b>: Missing positions\n",
        "#@markdown - <b><font color='#F0E442'>YELLOW </font></b>: WT amino acid\n",
        "\n",
        "#@markdown Changing the min_colormap value (suggested from -5 to -30) will make the heatmap closer to binary (~5) or more detailed (<<-5).\n",
        "\n",
        "#@markdown **N.B.:** residue numeration in the figure starts from 0 (remember to add +1 for original residue numeration).\n",
        "\n",
        "plot_width=50 #@param\n",
        "\n",
        "min_colormap=-20 #@param\n",
        "\n",
        "colour_map='Blues' #@param [\"Blues\", \"Greens\",\"Purples\"]\n",
        "\n",
        "heatmap_values_reordered(outscores_IF,'ESM-IF score',query_sequence,[0,len(query_sequence)-1],xtick_spacing=20,figs=[plot_width,6],where_save=plot_folder,title_figure=jobname+'_thermodynamic_stab',colour_map=colour_map,min_colour=min_colormap)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "_zG1NJc4eaip"
      },
      "outputs": [],
      "source": [
        "#@title <b><font color='#56b4e9'>Func-ESMs: </font>\n",
        "#@markdown Visualise the results of the classification for variants and residues using the query sequence/structure\\\n",
        "#@markdown \\\n",
        "#@markdown **Color keys:**\n",
        "#@markdown - <b><font color='#009E74'>GREEN </font></b>: **WT-like** (variants) and **Tolerant** (residues)\n",
        "#@markdown - <b><font color='#56b4e9'>BLUE </font></b>: **stable-but-inactive** (variants) or **functionally-relevant** (residues)\n",
        "#@markdown - <b><font color='#D55C00'>RED </font></b>: **total-loss** (variant) and **structurally-critical** (residue)\n",
        "#@markdown - <b>GRAY</b>: Mixed (residue)\n",
        "\n",
        "#@markdown \\\n",
        "#@markdown **N.B.:** residue numeration in the figure starts from 0 (remember to add +1 for original residue numeration).\n",
        "\n",
        "plot_width=50 #@param\n",
        "\n",
        "heatmap_classes_reordered(variants_class,'\\u0394\\u0394G [a.u]',query_sequence,[0,len(query_sequence)-1],WT_cmap='coolwarm',xtick_spacing=20,figs=[plot_width,6],where_save=plot_folder,title_figure=jobname,)\n",
        "\n",
        "residues_classes_reordered(residues_class,[0,len(query_sequence)-1],title_figure=jobname,where_save=plot_folder,figs=[plot_width,1],xtick_spacing=20)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "FCBTNMCiqQM6",
        "outputId": "2222b790-12ca-421f-bc65-6a66cfd20da3"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_70d5073e-bde5-4587-a538-292482961da2\", \"FunC-ESMs_outputs.zip\", 647111)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "#@title <b><font color='#56b4e9'>DOWNLOAD ALL RESULTS </font>\n",
        "#@markdown Run the cell to download predictions and figures for all proteins analysed in the current session as a zip file.\n",
        "os.system( \"zip -r {} {}\".format( f\"FunC-ESMs_outputs.zip\" , f\"FunC-ESMs_outputs\" ) )\n",
        "files.download(f\"FunC-ESMs_outputs.zip\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0NULd4ycW4dw"
      },
      "source": [
        "<b><font color='#56b4e9'>EXTRA </font></b>\n",
        "\n",
        "\\\\\n",
        "**Colab updates:**\n",
        "\n",
        "- <b>Oct2024</b>: Installation now use conda-lab, due to impossibility of installing torch dependencies with pip in reasonable amount of time. Walltime for installation is now 15minutes. Biotite functions updated for ESM-IF (required by new biotite package).\n",
        "\n",
        "**Known problems:**\n",
        "\n",
        "- The input structure must be a predicted structure from AlphaFold2 if possible. This is necessary to ensure maximum prediction quality as ESM-IF has been trained using the backbone from AlphaFold2.\n",
        "\n",
        "- The maximum size of proteins that can be used in the ESM-1B ESM-IF Colab implementation is 1023 residues, larger proteins cannot currently be handled by the Colab implementation.\n",
        "\n",
        "\n",
        "\n",
        "\\\\\n",
        "\n",
        "**License:**\n",
        "\n",
        "ESM models, the notebook code and FunC-ESMs source code are licensed under the MIT license found in the LICENSE file in the root directory of the GitHub page.\n",
        "\n",
        "\\\\\n",
        "\n",
        "**Bugs:**\n",
        "\n",
        "For any bugs please report the issue on the project [Github](https://github.com/KULL-Centre/_2024_cagiada-jonsson-func/tree/main) or contact one of the listed authors in the connected [manuscript](https://doi.org/).\n",
        "\n",
        "\\\\\n",
        "\n",
        "**Citing this work:**\n",
        "\n",
        "If you use our model please cite:\n",
        "\n",
        "Cagiada, Matteo, Nicolas Jonsson, and Kresten Lindorff-Larsen. \"Decoding molecular mechanisms for loss of function variants in the human proteome.\" bioRxiv (2024): 2024-05.\n",
        "\n",
        "```\n",
        "\n",
        "@article{cagiada2024decoding,\n",
        "  title={Decoding molecular mechanisms for loss of function variants in the human proteome},\n",
        "  author={Cagiada, Matteo and Jonsson, Nicolas and Lindorff-Larsen, Kresten},\n",
        "  journal={bioRxiv},\n",
        "  pages={2024--05},\n",
        "  year={2024},\n",
        "  publisher={Cold Spring Harbor Laboratory}\n",
        "}\n",
        "```\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}