{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "7TF3MtJc9MXb" }, "source": [ "## PDB to ESM-IF1 embeddings" ] }, { "cell_type": "markdown", "metadata": { "id": "U3tYZu3O9Pi0" }, "source": [ "In this notebook, I use [ESM-IF1 model](https://www.biorxiv.org/content/10.1101/2022.04.10.487779v1) to obtain antibody structure embedding for train/valid/test pdb files. For my work, I froze the ESM-IF1 model, and average pooled the antibody structure embeddings from the transformer encoder, following the procedure used in the [facebook research ESM-IF1 notebook](https://github.com/facebookresearch/esm/tree/main/examples/inverse_folding)." ] }, { "cell_type": "markdown", "metadata": { "id": "yUW_BzroStJy" }, "source": [ "## Setup" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AzSn1VSX9OVK", "outputId": "dca4bb82-c9d1-4d4b-f745-cd73a52ba5a2" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.9/10.9 MB\u001b[0m \u001b[31m69.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.1/5.1 MB\u001b[0m \u001b[31m28.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.4/3.4 MB\u001b[0m \u001b[31m20.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m947.1/947.1 kB\u001b[0m \u001b[31m8.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", " Building wheel for fair-esm (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.2/44.2 MB\u001b[0m \u001b[31m37.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h" ] } ], "source": [ "# Colab environment setup\n", "\n", "# Install the correct version of Pytorch Geometric.\n", "import torch\n", "\n", "def format_pytorch_version(version):\n", " return version.split('+')[0]\n", "\n", "TORCH_version = torch.__version__\n", "TORCH = format_pytorch_version(TORCH_version)\n", "\n", "def format_cuda_version(version):\n", " return 'cu' + version.replace('.', '')\n", "\n", "CUDA_version = torch.version.cuda\n", "CUDA = format_cuda_version(CUDA_version)\n", "\n", "!pip install -q torch-scatter -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html\n", "!pip install -q torch-sparse -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html\n", "!pip install -q torch-cluster -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html\n", "!pip install -q torch-spline-conv -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html\n", "!pip install -q torch-geometric\n", "\n", "# Install esm\n", "!pip install -q git+https://github.com/facebookresearch/esm.git\n", "\n", "# Install biotite\n", "!pip install -q biotite\n", "\n", "# Install proteinflow\n", "!pip install proteinflow &> /dev/null" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "zlQdEQErBELS" }, "outputs": [], "source": [ "## Verify that pytorch-geometric is correctly installed\n", "import torch_geometric\n", "import torch_sparse\n", "from torch_geometric.nn import MessagePassing" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "OsCMx5-lPTI7" }, "outputs": [], "source": [ "# Import necessary libraries\n", "import os\n", "import pickle\n", "import pandas as pd\n", "import torch\n", "from tqdm import tqdm\n", "from pathlib import Path\n", "import esm\n", "from proteinflow.data import ProteinEntry\n", "from fastcore.parallel import parallel" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "FwuYN81tBBLP", "outputId": "6b0b5373-0585-4043-c130-e68e00d3f51b" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", " and should_run_async(code)\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "Mounted at /content/gdrive\n" ] } ], "source": [ "from google.colab import drive\n", "drive.mount('/content/gdrive', force_remount=True)\n", "\n", "path = Path(\"/content/gdrive/\")\n", "path_data = Path(\"/content/gdrive/MyDrive/data\")" ] }, { "cell_type": "code", "source": [ "# Define directories\n", "train_folder = Path(\"/content/gdrive/MyDrive/data/proteinflow_20240520-0899946/train\")\n", "valid_folder = Path(\"/content/gdrive/MyDrive/data/proteinflow_20240520-0899946/valid\")\n", "test_folder = Path(\"/content/gdrive/MyDrive/data/proteinflow_20240520-0899946/test\")" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "oar04dtNMIQW", "outputId": "44043771-e506-4622-8a43-ac9d4affff62" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", " and should_run_async(code)\n" ] } ] }, { "cell_type": "markdown", "metadata": { "id": "7cNp6vPY4EgO" }, "source": [ "## PDB to ESM-IF1 embeddings" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "lt7K-nrqfBxG", "outputId": "9baacc6d-f99d-49dd-cda5-1de579d05f0a" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", " and should_run_async(code)\n" ] } ], "source": [ "import time\n", "\n", "# Load the ESM-IF1 model and move it to GPU\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "esm_if1_model, alphabet = esm.pretrained.esm_if1_gvp4_t16_142M_UR50()\n", "esm_if1_model = esm_if1_model.eval().to(device)\n", "\n", "# Function to process a batch of PDB files\n", "def process_pdb_batch(pdb_files):\n", " results = []\n", " for pdb_file in pdb_files:\n", " try:\n", " print(f\"Processing {pdb_file}...\") # Log progress\n", "\n", " # Load the protein entry from the pickle file\n", " protein_entry = ProteinEntry.from_pickle(pdb_file)\n", "\n", " # Convert to PDB format\n", " pdb_path = str(pdb_file).replace('.pickle', '.pdb')\n", " protein_entry.to_pdb(pdb_path)\n", "\n", " # Load the structure and extract coordinates and sequence\n", " structure = esm.inverse_folding.util.load_structure(pdb_path)\n", " coords, native_seq = esm.inverse_folding.util.extract_coords_from_structure(structure)\n", " coords = torch.tensor(coords, dtype=torch.float32).to(device)\n", "\n", " with torch.no_grad():\n", " rep = esm.inverse_folding.util.get_encoder_output(esm_if1_model, alphabet, coords)\n", "\n", " # Average pooling\n", " embedding = rep.mean(dim=0).detach().cpu().numpy()\n", "\n", " # Remove the temporary PDB file\n", " os.remove(pdb_path)\n", "\n", " # Add result to batch\n", " results.append({\n", " 'id': pdb_file.stem,\n", " 'sequence': native_seq,\n", " 'embedding': embedding\n", " })\n", "\n", " except Exception as e:\n", " print(f\"Error processing {pdb_file}: {e}\")\n", " results.append(None)\n", " return results\n", "\n", "# Function to process and extract data from PDB files in a directory using batching\n", "def process_pdb_files(data_dir, output_file, batch_size=8):\n", " pdb_files = list(data_dir.glob(\"*.pickle\"))\n", " all_results = []\n", "\n", " for i in tqdm(range(0, len(pdb_files), batch_size)):\n", " batch_files = pdb_files[i:i + batch_size]\n", " batch_results = process_pdb_batch(batch_files)\n", " all_results.extend(batch_results)\n", "\n", " # Filter out None results (errors)\n", " records = [result for result in all_results if result is not None]\n", "\n", " # Save the records to a DataFrame and then to a pickle file\n", " df = pd.DataFrame(records)\n", " df.to_pickle(output_file)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "tb7AAf72YV5G", "outputId": "ba93cff3-21f6-470e-d74d-fa371b9e2166" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", " and should_run_async(code)\n", " 0%| | 0/197 [00:00\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idsequenceembedding
04r4b-F_E_nanDIQMTQSPSFVSASVGDRVTITCRASQGISSYLAWYQQKPGKAPKL...[-0.06567193, -0.024550922, -0.08586867, -0.02...
14r4b-D_C_nanDIQMTQSPSFVSASVGDRVTITCRASQGISSYLAWYQQKPGKAPKL...[-0.05318726, -0.008427778, -0.082444064, -0.0...
24r4b-B_A_nanDIQMTQSPSFVSASVGDRVTITCRASQGISSYLAWYQQKPGKAPKL...[-0.07950935, -0.033451352, -0.079082675, -0.0...
34r4b-H_L_nanQVQLQQWGAGLLKPSETLSLTCGVYGESLSGHYWSWVRQPPGKRLE...[-0.07344883, -0.053831305, -0.08566607, -0.05...
41l7i-H_L_nanEVQLVESGGGLVQPGGSLRLSCAASGFTFTDYTMDWVRQAPGKGLE...[-0.028149318, -0.037230052, -0.1015465, -0.03...
\n", "
\n", "
\n", "\n", "
\n", " \n", "\n", " \n", "\n", " \n", "
\n", "\n", "\n", "
\n", " \n", "\n", "\n", "\n", " \n", "
\n", "\n", "
\n", " \n" ], "application/vnd.google.colaboratory.intrinsic+json": { "type": "dataframe", "variable_name": "train_df", "summary": "{\n \"name\": \"train_df\",\n \"rows\": 1567,\n \"fields\": [\n {\n \"column\": \"id\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 1567,\n \"samples\": [\n \"3grw-H_L_A\",\n \"8f5i-X_Y_A\",\n \"7xj9-I_H_C\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"sequence\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 1345,\n \"samples\": [\n \"KIEEGKLVIWINGDKGYNGLAEVGKKFEKDTGIKVTVEHPDKLEEKFPQVAATGDGPDIIFWAHDRFGGYAQSGLLAEITPDKAFQDKLYPFTWDAVRYNGKLIAYPIAVEALSLIYNKDLLPNPPKTWEEIPALDKELKAKGKSALMFNLQEPYFTWPLIAADGGYAFKYENGKYDIKDVGVDNAGAKAGLTFLVDLIKNKHMNADTDYSIAEAAFNKGETAMTINGPWAWSNIDTSKVNYGVTVLPTFKGQPSKPFVGVLSAGINAASPNKELAKEFLENYLLTDEGLEAVNKDKPLGAVALKSYEEELAKDPRIAATMENAQKGEIMPNIPQMSAFWYAVRTAVINAASGRQTVDEALKDAQTVQLVESGGGLVQPGGSLRLSCAASGFNVYYSSIHWVRQAPGKGLEWVASIYSYYGSTSYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCAREYHSYVYEPPLYGMDYWGQGTLVTVSSASTKGPSVFPLAPSKSTSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTQTYICNVNHKPSNTKVDKKVEPKSCSPSSLSASVGDRVTITCRASQSVSSAVAWYQQKPGSAPSLLIYSASSLYSGVPSRFSGSRSGTDFTLTISSLQPEDFATYYCQQSPQGYLVTFGQGTKVEIKRTVAAPSVFIFPPSDSQLKSGTASVVCLLNNFYPREAKVQWSVDNALQSGNSQESVTEQDSKDSTYSLSSTLTLSSADYEKHKVYACEVTHQGLSSPVTKSFNRGEC\",\n \"DIQMTQSPSSLSASVGDRVTITCRASQGISSSLAWYQQKPGKAPKLLIYGASETESGVPSRFSGSGSGTDFTLTISSLQPEDFATYYCQNTKVGSSYGNTFGGGTKVEIKRTVAAPSVFIFPPSDEQLKSGTASVVCLLNNFYPREAKVQWKVDNALQSGNSQESVTEQDSKDSTYSLSSTLTLSKADYEKHKVYACEVTHQGLSSPVTKSFNRGECVQLVESGGGLVQPGRSLRLSCAASGFTVHSSYYMAWVRQAPGKGLEWVGAIFTGSGAEYKAEWAKGRVTISKDTSKNQVVLTMTNMDPVDTATYYCASDAGYDYPTHAMHYWGQGTLVTVSSASTKGPSVFPLAPCSRSGGTAALGCLVKDYFPEPVTVSWNSGALTSGVHTFPAVLQSSGLYSLSSVVTVPSSSLGTKTYTCNVDHKPSNTKVDKRVESKYEQTYVISAPKIFRVGASENIVIQVYGYTEAFDATISIKSYPDKKFSYSSGHVHLSSENKFQNSAILTIQPVSYVYLEVVSKHFSKSKRMPITY\",\n \"HEVVKFMDVYQRSYCHPIETLVDIFQEYPDEIEYIFKPSCVPLMRCGGCCNDEGLECVPTEESNITMQIMRIKPHQGQHIGEMSFLQHNKCECRPKKVQLVESGGGLVQPGGSLRLSCAASGFNIKDTYIGWVRRAPGKGEELVARIYPTNGYTRYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCYYHYYGWHPGYGLSYSSGQGTLVTVS\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"embedding\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" } }, "metadata": {}, "execution_count": 22 } ], "source": [ "train_df = pd.read_pickle(path_data/'proteinflow_esmif1_20240520-0899946/train_data.pkl')\n", "valid_df = pd.read_pickle(path_data/'proteinflow_esmif1_20240520-0899946/valid_data.pkl')\n", "test_df = pd.read_pickle(path_data/'proteinflow_esmif1_20240520-0899946/test_data.pkl')\n", "train_df.head()" ] }, { "cell_type": "code", "source": [ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "# Set up the matplotlib figure\n", "plt.figure(figsize=(18, 5))\n", "\n", "plt.subplot(1, 3, 1)\n", "sns.histplot(train_df['sequence'].apply(lambda x: len(x)).values, kde=True)\n", "plt.subplot(1, 3, 2)\n", "sns.histplot(valid_df['sequence'].apply(lambda x: len(x)).values, kde=True)\n", "plt.subplot(1, 3, 3)\n", "sns.histplot(test_df['sequence'].apply(lambda x: len(x)).values, kde=True);" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 489 }, "id": "RMLQ3WCThNl2", "outputId": "c6a60940-99d9-419a-fb9d-ebf69d86a244" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n", " and should_run_async(code)\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ] }, { "cell_type": "code", "source": [], "metadata": { "id": "O9C1pJwQh4Nm" }, "execution_count": null, "outputs": [] } ], "metadata": { "colab": { "machine_shape": "hm", "provenance": [], "gpuType": "A100", "authorship_tag": "ABX9TyPgE9nAxtMocqbi8P3kogQ7", "include_colab_link": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "name": "python" }, "accelerator": "GPU" }, "nbformat": 4, "nbformat_minor": 0 }