![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G4yBrceuFbf3"
+ },
+ "source": [
+ "![](\"https://raw.githubusercontent.com/sokrypton/ColabFold/main/.github/ColabFold_Marv_Logo_Small.png\"){kind=logo}
\n",
+ "\n",
+ "##ColabFold v1.6.1: AlphaFold2 using MMseqs2\n",
+ "\n",
+ "Easy to use protein structure and complex prediction using [AlphaFold2](https://www.nature.com/articles/s41586-021-03819-2) and [Alphafold2-multimer](https://www.biorxiv.org/content/10.1101/2021.10.04.463034v1). Sequence alignments/templates are generated through [MMseqs2](mmseqs.com) and [HHsearch](https://github.com/soedinglab/hh-suite). For more details, see bottom of the notebook, checkout the [ColabFold GitHub](https://github.com/sokrypton/ColabFold) and [Nature Protocols](https://www.nature.com/articles/s41596-024-01060-5).\n",
+ "\n",
+ "Old versions: [v1.4](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.4.0/AlphaFold2.ipynb), [v1.5.1](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.5.1/AlphaFold2.ipynb), [v1.5.2](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.5.2/AlphaFold2.ipynb), [v1.5.3-patch](https://colab.research.google.com/github/sokrypton/ColabFold/blob/56c72044c7d51a311ca99b953a71e552fdc042e1/AlphaFold2.ipynb)\n",
+ "\n",
+ "[Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold: Making protein folding accessible to all.\n",
+ "*Nature Methods*, 2022](https://www.nature.com/articles/s41592-022-01488-1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kOblAo-xetgx",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Input protein sequence(s), then hit `Runtime` -> `Run all`\n",
+ "from google.colab import files\n",
+ "import os\n",
+ "import re\n",
+ "import hashlib\n",
+ "import random\n",
+ "\n",
+ "from sys import version_info\n",
+ "python_version = f\"{version_info.major}.{version_info.minor}\"\n",
+ "\n",
+ "def add_hash(x,y):\n",
+ " return x+\"_\"+hashlib.sha1(y.encode()).hexdigest()[:5]\n",
+ "\n",
+ "query_sequence = 'PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK' #@param {type:\"string\"}\n",
+ "#@markdown - Use `:` to specify inter-protein chainbreaks for **modeling complexes** (supports homo- and hetro-oligomers). For example **PI...SK:PI...SK** for a homodimer\n",
+ "jobname = 'test' #@param {type:\"string\"}\n",
+ "# number of models to use\n",
+ "num_relax = 0 #@param [0, 1, 5] {type:\"raw\"}\n",
+ "#@markdown - specify how many of the top ranked structures to relax using amber\n",
+ "template_mode = \"none\" #@param [\"none\", \"pdb100\",\"custom\"]\n",
+ "#@markdown - `none` = no template information is used. `pdb100` = detect templates in pdb100 (see [notes](#pdb100)). `custom` - upload and search own templates (PDB or mmCIF format, see [notes](#custom_templates))\n",
+ "\n",
+ "use_amber = num_relax > 0\n",
+ "\n",
+ "# remove whitespaces\n",
+ "query_sequence = \"\".join(query_sequence.split())\n",
+ "\n",
+ "basejobname = \"\".join(jobname.split())\n",
+ "basejobname = re.sub(r'\\W+', '', basejobname)\n",
+ "jobname = add_hash(basejobname, query_sequence)\n",
+ "\n",
+ "# check if directory with jobname exists\n",
+ "def check(folder):\n",
+ " if os.path.exists(folder):\n",
+ " return False\n",
+ " else:\n",
+ " return True\n",
+ "if not check(jobname):\n",
+ " n = 0\n",
+ " while not check(f\"{jobname}_{n}\"): n += 1\n",
+ " jobname = f\"{jobname}_{n}\"\n",
+ "\n",
+ "# make directory to save results\n",
+ "os.makedirs(jobname, exist_ok=True)\n",
+ "\n",
+ "# save queries\n",
+ "queries_path = os.path.join(jobname, f\"{jobname}.csv\")\n",
+ "with open(queries_path, \"w\") as text_file:\n",
+ " text_file.write(f\"id,sequence\\n{jobname},{query_sequence}\")\n",
+ "\n",
+ "if template_mode == \"pdb100\":\n",
+ " use_templates = True\n",
+ " custom_template_path = None\n",
+ "elif template_mode == \"custom\":\n",
+ " custom_template_path = os.path.join(jobname,f\"template\")\n",
+ " os.makedirs(custom_template_path, exist_ok=True)\n",
+ " uploaded = files.upload()\n",
+ " use_templates = True\n",
+ " for fn in uploaded.keys():\n",
+ " os.rename(fn,os.path.join(custom_template_path,fn))\n",
+ "else:\n",
+ " custom_template_path = None\n",
+ " use_templates = False\n",
+ "\n",
+ "print(\"jobname\",jobname)\n",
+ "print(\"sequence\",query_sequence)\n",
+ "print(\"length\",len(query_sequence.replace(\":\",\"\")))"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Install dependencies\n",
+ "%%time\n",
+ "import os\n",
+ "USE_AMBER = use_amber\n",
+ "USE_TEMPLATES = use_templates\n",
+ "PYTHON_VERSION = python_version\n",
+ "\n",
+ "if not os.path.isfile(\"COLABFOLD_READY\"):\n",
+ " print(\"installing colabfold...\")\n",
+ " os.system(\"pip install -q --no-warn-conflicts 'colabfold[alphafold-minus-jax] @ git+https://github.com/sokrypton/ColabFold'\")\n",
+ " if os.environ.get('TPU_NAME', False) != False:\n",
+ " os.system(\"pip uninstall -y jax jaxlib\")\n",
+ " os.system(\"pip install --no-warn-conflicts --upgrade dm-haiku==0.0.10 'jax[cuda12_pip]'==0.3.25 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html\")\n",
+ " os.system(\"ln -s /usr/local/lib/python3.*/dist-packages/colabfold colabfold\")\n",
+ " os.system(\"ln -s /usr/local/lib/python3.*/dist-packages/alphafold alphafold\")\n",
+ " # hack to fix TF crash\n",
+ " os.system(\"rm -f /usr/local/lib/python3.*/dist-packages/tensorflow/core/kernels/libtfkernel_sobol_op.so /usr/local/lib/python3.*/dist-packages/tensorflow/lite/python/*/*.so\")\n",
+ " os.system(\"touch COLABFOLD_READY\")\n",
+ "\n",
+ "if USE_AMBER or USE_TEMPLATES:\n",
+ " if not os.path.isfile(\"CONDA_READY\"):\n",
+ " print(\"installing conda...\")\n",
+ " os.system(\"wget -qnc https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh\")\n",
+ " os.system(\"bash Miniforge3-Linux-x86_64.sh -bfp /usr/local\")\n",
+ " os.system(\"mamba config --set auto_update_conda false\")\n",
+ " os.system(\"touch CONDA_READY\")\n",
+ "\n",
+ "if USE_TEMPLATES and not os.path.isfile(\"HH_READY\") and USE_AMBER and not os.path.isfile(\"AMBER_READY\"):\n",
+ " print(\"installing hhsuite and amber...\")\n",
+ " os.system(f\"mamba install -y -c conda-forge -c bioconda kalign2=2.04 hhsuite=3.3.0 openmm=8.2.0 python='{PYTHON_VERSION}' pdbfixer\")\n",
+ " os.system(\"touch HH_READY\")\n",
+ " os.system(\"touch AMBER_READY\")\n",
+ "else:\n",
+ " if USE_TEMPLATES and not os.path.isfile(\"HH_READY\"):\n",
+ " print(\"installing hhsuite...\")\n",
+ " os.system(f\"mamba install -y -c conda-forge -c bioconda kalign2=2.04 hhsuite=3.3.0 python='{PYTHON_VERSION}'\")\n",
+ " os.system(\"touch HH_READY\")\n",
+ " if USE_AMBER and not os.path.isfile(\"AMBER_READY\"):\n",
+ " print(\"installing amber...\")\n",
+ " os.system(f\"mamba install -y -c conda-forge openmm=8.2.0 python='{PYTHON_VERSION}' pdbfixer\")\n",
+ " os.system(\"touch AMBER_READY\")"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "AzIKiDiCaHAn"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@markdown ### MSA options (custom MSA upload, single sequence, pairing mode)\n",
+ "msa_mode = \"mmseqs2_uniref_env\" #@param [\"mmseqs2_uniref_env\", \"mmseqs2_uniref\",\"single_sequence\",\"custom\"]\n",
+ "pair_mode = \"unpaired_paired\" #@param [\"unpaired_paired\",\"paired\",\"unpaired\"] {type:\"string\"}\n",
+ "#@markdown - \"unpaired_paired\" = pair sequences from same species + unpaired MSA, \"unpaired\" = seperate MSA for each chain, \"paired\" - only use paired sequences.\n",
+ "\n",
+ "# decide which a3m to use\n",
+ "if \"mmseqs2\" in msa_mode:\n",
+ " a3m_file = os.path.join(jobname,f\"{jobname}.a3m\")\n",
+ "\n",
+ "elif msa_mode == \"custom\":\n",
+ " a3m_file = os.path.join(jobname,f\"{jobname}.custom.a3m\")\n",
+ " if not os.path.isfile(a3m_file):\n",
+ " custom_msa_dict = files.upload()\n",
+ " custom_msa = list(custom_msa_dict.keys())[0]\n",
+ " header = 0\n",
+ " import fileinput\n",
+ " for line in fileinput.FileInput(custom_msa,inplace=1):\n",
+ " if line.startswith(\">\"):\n",
+ " header = header + 1\n",
+ " if not line.rstrip():\n",
+ " continue\n",
+ " if line.startswith(\">\") == False and header == 1:\n",
+ " query_sequence = line.rstrip()\n",
+ " print(line, end='')\n",
+ "\n",
+ " os.rename(custom_msa, a3m_file)\n",
+ " queries_path=a3m_file\n",
+ " print(f\"moving {custom_msa} to {a3m_file}\")\n",
+ "\n",
+ "else:\n",
+ " a3m_file = os.path.join(jobname,f\"{jobname}.single_sequence.a3m\")\n",
+ " with open(a3m_file, \"w\") as text_file:\n",
+ " text_file.write(\">1\\n%s\" % query_sequence)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "C2_sh2uAonJH"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@markdown ### Advanced settings\n",
+ "model_type = \"auto\" #@param [\"auto\", \"alphafold2_ptm\", \"alphafold2_multimer_v1\", \"alphafold2_multimer_v2\", \"alphafold2_multimer_v3\", \"deepfold_v1\", \"alphafold2\"]\n",
+ "#@markdown - if `auto` selected, will use `alphafold2_ptm` for monomer prediction and `alphafold2_multimer_v3` for complex prediction.\n",
+ "#@markdown Any of the mode_types can be used (regardless if input is monomer or complex).\n",
+ "num_recycles = \"3\" #@param [\"auto\", \"0\", \"1\", \"3\", \"6\", \"12\", \"24\", \"48\"]\n",
+ "#@markdown - if `auto` selected, will use `num_recycles=20` if `model_type=alphafold2_multimer_v3`, else `num_recycles=3` .\n",
+ "recycle_early_stop_tolerance = \"auto\" #@param [\"auto\", \"0.0\", \"0.5\", \"1.0\"]\n",
+ "#@markdown - if `auto` selected, will use `tol=0.5` if `model_type=alphafold2_multimer_v3` else `tol=0.0`.\n",
+ "relax_max_iterations = 200 #@param [0, 200, 2000] {type:\"raw\"}\n",
+ "#@markdown - max amber relax iterations, `0` = unlimited (AlphaFold2 default, can take very long)\n",
+ "pairing_strategy = \"greedy\" #@param [\"greedy\", \"complete\"] {type:\"string\"}\n",
+ "#@markdown - `greedy` = pair any taxonomically matching subsets, `complete` = all sequences have to match in one line.\n",
+ "calc_extra_ptm = False #@param {type:\"boolean\"}\n",
+ "#@markdown - return pairwise chain iptm/actifptm\n",
+ "\n",
+ "#@markdown #### Sample settings\n",
+ "#@markdown - enable dropouts and increase number of seeds to sample predictions from uncertainty of the model.\n",
+ "#@markdown - decrease `max_msa` to increase uncertainity\n",
+ "max_msa = \"auto\" #@param [\"auto\", \"512:1024\", \"256:512\", \"64:128\", \"32:64\", \"16:32\"]\n",
+ "num_seeds = 1 #@param [1,2,4,8,16] {type:\"raw\"}\n",
+ "use_dropout = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "num_recycles = None if num_recycles == \"auto\" else int(num_recycles)\n",
+ "recycle_early_stop_tolerance = None if recycle_early_stop_tolerance == \"auto\" else float(recycle_early_stop_tolerance)\n",
+ "if max_msa == \"auto\": max_msa = None\n",
+ "\n",
+ "#@markdown #### Save settings\n",
+ "save_all = False #@param {type:\"boolean\"}\n",
+ "save_recycles = False #@param {type:\"boolean\"}\n",
+ "save_to_google_drive = False #@param {type:\"boolean\"}\n",
+ "#@markdown - if the save_to_google_drive option was selected, the result zip will be uploaded to your Google Drive\n",
+ "dpi = 200 #@param {type:\"integer\"}\n",
+ "#@markdown - set dpi for image resolution\n",
+ "\n",
+ "if save_to_google_drive:\n",
+ " from pydrive2.drive import GoogleDrive\n",
+ " from pydrive2.auth import GoogleAuth\n",
+ " from google.colab import auth\n",
+ " from oauth2client.client import GoogleCredentials\n",
+ " auth.authenticate_user()\n",
+ " gauth = GoogleAuth()\n",
+ " gauth.credentials = GoogleCredentials.get_application_default()\n",
+ " drive = GoogleDrive(gauth)\n",
+ " print(\"You are logged into Google Drive and are good to go!\")\n",
+ "\n",
+ "#@markdown Don't forget to hit `Runtime` -> `Run all` after updating the form."
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "ADDuaolKmjGW"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Run Prediction\n",
+ "display_images = True #@param {type:\"boolean\"}\n",
+ "\n",
+ "import sys\n",
+ "import warnings\n",
+ "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+ "from Bio import BiopythonDeprecationWarning\n",
+ "warnings.simplefilter(action='ignore', category=BiopythonDeprecationWarning)\n",
+ "from pathlib import Path\n",
+ "from colabfold.download import download_alphafold_params, default_data_dir\n",
+ "from colabfold.utils import setup_logging\n",
+ "from colabfold.batch import get_queries, run, set_model_type\n",
+ "from colabfold.plot import plot_msa_v2\n",
+ "\n",
+ "import os\n",
+ "import numpy as np\n",
+ "try:\n",
+ " K80_chk = os.popen('nvidia-smi | grep \"Tesla K80\" | wc -l').read()\n",
+ "except:\n",
+ " K80_chk = \"0\"\n",
+ " pass\n",
+ "if \"1\" in K80_chk:\n",
+ " print(\"WARNING: found GPU Tesla K80: limited to total length < 1000\")\n",
+ " if \"TF_FORCE_UNIFIED_MEMORY\" in os.environ:\n",
+ " del os.environ[\"TF_FORCE_UNIFIED_MEMORY\"]\n",
+ " if \"XLA_PYTHON_CLIENT_MEM_FRACTION\" in os.environ:\n",
+ " del os.environ[\"XLA_PYTHON_CLIENT_MEM_FRACTION\"]\n",
+ "\n",
+ "from colabfold.colabfold import plot_protein\n",
+ "from pathlib import Path\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "# For some reason we need that to get pdbfixer to import\n",
+ "if use_amber and f\"/usr/local/lib/python{python_version}/site-packages/\" not in sys.path:\n",
+ " sys.path.insert(0, f\"/usr/local/lib/python{python_version}/site-packages/\")\n",
+ "\n",
+ "def input_features_callback(input_features):\n",
+ " if display_images:\n",
+ " plot_msa_v2(input_features)\n",
+ " plt.show()\n",
+ " plt.close()\n",
+ "\n",
+ "def prediction_callback(protein_obj, length,\n",
+ " prediction_result, input_features, mode):\n",
+ " model_name, relaxed = mode\n",
+ " if not relaxed:\n",
+ " if display_images:\n",
+ " fig = plot_protein(protein_obj, Ls=length, dpi=150)\n",
+ " plt.show()\n",
+ " plt.close()\n",
+ "\n",
+ "result_dir = jobname\n",
+ "log_filename = os.path.join(jobname,\"log.txt\")\n",
+ "setup_logging(Path(log_filename))\n",
+ "\n",
+ "queries, is_complex = get_queries(queries_path)\n",
+ "model_type = set_model_type(is_complex, model_type)\n",
+ "\n",
+ "if \"multimer\" in model_type and max_msa is not None:\n",
+ " use_cluster_profile = False\n",
+ "else:\n",
+ " use_cluster_profile = True\n",
+ "\n",
+ "download_alphafold_params(model_type, Path(\".\"))\n",
+ "results = run(\n",
+ " queries=queries,\n",
+ " result_dir=result_dir,\n",
+ " use_templates=use_templates,\n",
+ " custom_template_path=custom_template_path,\n",
+ " num_relax=num_relax,\n",
+ " msa_mode=msa_mode,\n",
+ " model_type=model_type,\n",
+ " num_models=5,\n",
+ " num_recycles=num_recycles,\n",
+ " relax_max_iterations=relax_max_iterations,\n",
+ " recycle_early_stop_tolerance=recycle_early_stop_tolerance,\n",
+ " num_seeds=num_seeds,\n",
+ " use_dropout=use_dropout,\n",
+ " model_order=[1,2,3,4,5],\n",
+ " is_complex=is_complex,\n",
+ " data_dir=Path(\".\"),\n",
+ " keep_existing_results=False,\n",
+ " rank_by=\"auto\",\n",
+ " pair_mode=pair_mode,\n",
+ " pairing_strategy=pairing_strategy,\n",
+ " stop_at_score=float(100),\n",
+ " prediction_callback=prediction_callback,\n",
+ " dpi=dpi,\n",
+ " zip_results=False,\n",
+ " save_all=save_all,\n",
+ " max_msa=max_msa,\n",
+ " use_cluster_profile=use_cluster_profile,\n",
+ " input_features_callback=input_features_callback,\n",
+ " save_recycles=save_recycles,\n",
+ " user_agent=\"colabfold/google-colab-main\",\n",
+ " calc_extra_ptm=calc_extra_ptm,\n",
+ ")\n",
+ "results_zip = f\"{jobname}.result.zip\"\n",
+ "os.system(f\"zip -r {results_zip} {jobname}\")"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "mbaIO9pWjaN0"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KK7X9T44pWb7",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "import py3Dmol\n",
+ "import glob\n",
+ "import matplotlib.pyplot as plt\n",
+ "from colabfold.colabfold import plot_plddt_legend\n",
+ "from colabfold.colabfold import pymol_color_list, alphabet_list\n",
+ "rank_num = 1 #@param [\"1\", \"2\", \"3\", \"4\", \"5\"] {type:\"raw\"}\n",
+ "color = \"lDDT\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "tag = results[\"rank\"][0][rank_num - 1]\n",
+ "jobname_prefix = \".custom\" if msa_mode == \"custom\" else \"\"\n",
+ "pdb_filename = f\"{jobname}/{jobname}{jobname_prefix}_unrelaxed_{tag}.pdb\"\n",
+ "pdb_file = glob.glob(pdb_filename)\n",
+ "\n",
+ "def show_pdb(rank_num=1, show_sidechains=False, show_mainchains=False, color=\"lDDT\"):\n",
+ " model_name = f\"rank_{rank_num}\"\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
+ " view.addModel(open(pdb_file[0],'r').read(),'pdb')\n",
+ "\n",
+ " if color == \"lDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':50,'max':90}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " chains = len(queries[0][1]) + 1 if is_complex else 1\n",
+ " for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ "\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ "\n",
+ " view.zoomTo()\n",
+ " return view\n",
+ "\n",
+ "show_pdb(rank_num, show_sidechains, show_mainchains, color).show()\n",
+ "if color == \"lDDT\":\n",
+ " plot_plddt_legend().show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "11l8k--10q0C",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Plots {run: \"auto\"}\n",
+ "from IPython.display import display, HTML\n",
+ "import base64\n",
+ "from html import escape\n",
+ "\n",
+ "# see: https://stackoverflow.com/a/53688522\n",
+ "def image_to_data_url(filename):\n",
+ " ext = filename.split('.')[-1]\n",
+ " prefix = f'data:image/{ext};base64,'\n",
+ " with open(filename, 'rb') as f:\n",
+ " img = f.read()\n",
+ " return prefix + base64.b64encode(img).decode('utf-8')\n",
+ "\n",
+ "pae = \"\"\n",
+ "pae_file = os.path.join(jobname,f\"{jobname}{jobname_prefix}_pae.png\")\n",
+ "if os.path.isfile(pae_file):\n",
+ " pae = image_to_data_url(pae_file)\n",
+ "cov = image_to_data_url(os.path.join(jobname,f\"{jobname}{jobname_prefix}_coverage.png\"))\n",
+ "plddt = image_to_data_url(os.path.join(jobname,f\"{jobname}{jobname_prefix}_plddt.png\"))\n",
+ "display(HTML(f\"\"\"\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "header",
+ "metadata": {
+ "id": "header"
+ },
+ "source": [
+ "# AlphaFold 3 (OpenFold3 Preview 2 weights)\n",
+ "\n",
+ "Predict protein, RNA, DNA, and small-molecule structures using [AlphaFold 3](https://www.nature.com/articles/s41586-024-07487-w) with the freely available [OpenFold3](https://github.com/aqlaboratory/openfold) weights (Apache 2.0 — no commercial restrictions).\n",
+ "\n",
+ "MSA generation via the [ColabFold](https://github.com/sokrypton/ColabFold) MMseqs2 server — **no local databases required**.\n",
+ "\n",
+ "Just fill in the **Input sequence(s)** cell and run all. Proteins, nucleic acids and ligands all go in a single box; attention/XLA flags are chosen automatically for your runtime (T4, newer GPUs, or CPU).\n",
+ "\n",
+ "**Citations:**\n",
+ "- Abramson et al. (2024) AlphaFold 3. *Nature* [doi:10.1038/s41586-024-07487-w](https://doi.org/10.1038/s41586-024-07487-w)\n",
+ "- Mirdita et al. (2022) ColabFold. *Nature Methods* [doi:10.1038/s41592-022-01488-1](https://doi.org/10.1038/s41592-022-01488-1)\n",
+ "- The OpenFold3 Team (2025) [Github](https://github.com/aqlaboratory/openfold-3) - [doi:10.5281/zenodo.19001000](https://doi.org/10.5281/zenodo.19001000)\n",
+ "\n",
+ "**Credits:** AF3 code: Google DeepMind (Apache 2.0) · OF3 weights: AlQuraishi Lab (Apache 2.0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "install",
+ "metadata": {
+ "cellView": "form",
+ "id": "install"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Install dependencies (~3 mins)\n",
+ "%%time\n",
+ "import os, time, glob\n",
+ "\n",
+ "weights_url = '' #@param {type:\"string\"}\n",
+ "#@markdown - **weights_url**: leave EMPTY to use the free, open **OpenFold3** weights. To use\n",
+ "#@markdown the official **AlphaFold 3** weights, paste the Google Cloud URL: `https://storage.googleapis.com/alphafold3/models/[???]/af3.bin.zst` from your DeepMind\n",
+ "#@markdown approval email (you'll be prompted to authenticate). Subject to the AF3 weights terms of use.\n",
+ "weights_url = weights_url.strip()\n",
+ "USE_NATIVE = bool(weights_url)\n",
+ "NATIVE_DIR = 'af3_native_weights'\n",
+ "\n",
+ "if not os.path.isfile('ALPHAFOLD3_READY'):\n",
+ " print('Installing packages...')\n",
+ " os.system(\"pip install -q 'jax[cuda12]==0.10.1' dm-haiku==0.0.16 rdkit==2025.9.4 \\\n",
+ " zstandard awscli tokamax==0.0.11 py3Dmol py2Dmol\")\n",
+ " os.system(\"pip install -q --no-deps 'https://github.com/sokrypton/alphafold3/releases/download/v3.1.0/alphafold3_open-3.1.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl'\")\n",
+ " base = 'https://raw.githubusercontent.com/sokrypton/alphafold3/refs/heads/main'\n",
+ " for script in ['run_alphafold', 'convert_of3_weights']:\n",
+ " os.system(f'wget -q -nc {base}/{script}.py')\n",
+ " os.system('touch ALPHAFOLD3_READY')\n",
+ " print('Packages installed.')\n",
+ "\n",
+ "# Patch tokamax so Ada/consumer GPUs (L4, A10, RTX 30/40; cc 8.6/8.9) fall back to XLA\n",
+ "# kernels. tokamax enables its Triton kernels for ALL cc>=8.0 GPUs, but those kernels\n",
+ "# need more shared memory than Ada cards have -> 'Shared memory size limit exceeded' at\n",
+ "# launch (which its trace-time fallback can't catch). Restrict Triton to true datacenter\n",
+ "# GPUs (A100 cc 8.0, H100 cc 9.0+); everything else uses XLA, exactly like the T4 path.\n",
+ "try:\n",
+ " import tokamax\n",
+ " _gu = os.path.join(os.path.dirname(tokamax.__file__), '_src', 'gpu_utils.py')\n",
+ " _s = open(_gu).read()\n",
+ " _old = 'return float(device.compute_capability) >= 8.0'\n",
+ " _new = ('cc = float(device.compute_capability)\\n'\n",
+ " ' return cc == 8.0 or cc >= 9.0 # datacenter only; Ada/L4 (8.6/8.9) lack shared memory')\n",
+ " if _old in _s:\n",
+ " open(_gu, 'w').write(_s.replace(_old, _new))\n",
+ " print('Patched tokamax: Triton restricted to datacenter GPUs (L4/Ada -> XLA).')\n",
+ "except Exception as _e:\n",
+ " print(f'(tokamax patch skipped: {_e})')\n",
+ "\n",
+ "# Weights: official AlphaFold 3 (if a URL was given) or OpenFold3 (default, free)\n",
+ "if USE_NATIVE:\n",
+ " if not os.path.isfile('NATIVE_WEIGHTS_DONE'):\n",
+ " print('Fetching official AlphaFold 3 weights (Google authentication required)...')\n",
+ " from google.colab import auth\n",
+ " auth.authenticate_user()\n",
+ " from google.cloud import storage\n",
+ " weights_path = weights_url.removeprefix('https://storage.googleapis.com/alphafold3/')\n",
+ " blob = storage.Client().bucket('alphafold3').get_blob(weights_path)\n",
+ " if blob is None:\n",
+ " raise FileNotFoundError(f'No weights found at {weights_url} - check the URL and that your account was granted access.')\n",
+ " af3_weights = blob.open('rb').read()\n",
+ " print(f'Loaded AlphaFold 3 weights ({len(af3_weights):,} bytes)')\n",
+ " os.makedirs(NATIVE_DIR, exist_ok=True)\n",
+ " for _f in glob.glob(f'{NATIVE_DIR}/*'): # keep exactly one model file in the dir\n",
+ " os.remove(_f)\n",
+ " _name = os.path.basename(weights_path)\n",
+ " if not (_name.endswith('.bin') or _name.endswith('.bin.zst')):\n",
+ " _name = 'af3.bin.zst' if af3_weights[:4] == b'\\x28\\xb5\\x2f\\xfd' else 'af3.bin' # zstd magic\n",
+ " with open(f'{NATIVE_DIR}/{_name}', 'wb') as _fh:\n",
+ " _fh.write(af3_weights)\n",
+ " open('NATIVE_WEIGHTS_DONE', 'w').close()\n",
+ " print(f'Saved native weights -> {NATIVE_DIR}/{_name}')\n",
+ "elif not os.path.isfile('WEIGHTS_DONE'):\n",
+ " print('Downloading OpenFold3 weights...')\n",
+ " os.system('(aws s3 cp s3://openfold/staging/of3-p2-155k.pt . --no-sign-request; touch WEIGHTS_DONE) &')\n",
+ "\n",
+ "# Build AF3 data files (background, independent of weights)\n",
+ "if not os.path.isfile('DATA_DONE'):\n",
+ " print('Building AF3 data files...')\n",
+ " os.system('(build_data; touch DATA_DONE) &')\n",
+ "\n",
+ "# Wait for background jobs (the OF3 download only matters for the OpenFold3 path)\n",
+ "for sentinel in (['DATA_DONE'] if USE_NATIVE else ['WEIGHTS_DONE', 'DATA_DONE']):\n",
+ " while not os.path.isfile(sentinel):\n",
+ " time.sleep(5)\n",
+ " print(f'{sentinel} ✓')\n",
+ "\n",
+ "if not USE_NATIVE and not os.path.isfile('af3_converted_weights/of3_ported_weights.bin.zst'):\n",
+ " print(\"converting openfold3 weights...\")\n",
+ " os.system(\"python convert_of3_weights.py --of3_checkpoint of3-p2-155k.pt --output_dir af3_converted_weights\")\n",
+ "\n",
+ "print('Setup complete! ' + ('Using official AlphaFold 3 weights.' if USE_NATIVE else 'Using OpenFold3 weights.'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "input",
+ "metadata": {
+ "id": "input",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Input sequences\n",
+ "import re, os, json, hashlib\n",
+ "\n",
+ "#@markdown ### Molecules\n",
+ "#@markdown Separate multiple chains within a box using `:` (extra colons are fine: `A::::B` == `A:B`). Leave a box empty if unused; full details in the Instructions cell.\n",
+ "protein = 'PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK' #@param {type:\"string\"}\n",
+ "dna = '' #@param {type:\"string\"}\n",
+ "rna = '' #@param {type:\"string\"}\n",
+ "ligand_ccd = '' #@param {type:\"string\"}\n",
+ "ligand_smiles = '' #@param {type:\"string\"}\n",
+ "\n",
+ "#@markdown ### Run settings\n",
+ "jobname = 'test' #@param {type:\"string\"}\n",
+ "msa_mode = \"mmseqs2_server\" #@param [\"mmseqs2_server\", \"single_sequence\"]\n",
+ "seeds = '1' #@param {type:\"string\"}\n",
+ "on_existing = \"overwrite\" #@param [\"overwrite\", \"skip\"]\n",
+ "#@markdown - `msa_mode`: `single_sequence` skips the MSA (faster, lower accuracy).\n",
+ "#@markdown - `seeds`: comma-separated, e.g. `1,2,3`.\n",
+ "#@markdown - `on_existing`: `overwrite` replaces this job's previous results; `skip` keeps them.\n",
+ "\n",
+ "# Split a box into entries: collapse colon runs, drop whitespace, skip empties\n",
+ "def split_entries(s):\n",
+ " s = re.sub(r':+', ':', s).strip(':')\n",
+ " return [e for e in (''.join(tok.split()) for tok in s.split(':')) if e]\n",
+ "\n",
+ "prot_seqs = [e.upper() for e in split_entries(protein)]\n",
+ "dna_seqs = [e.upper() for e in split_entries(dna)]\n",
+ "rna_seqs = [e.upper() for e in split_entries(rna)]\n",
+ "ccd_codes = [e.upper() for e in split_entries(ligand_ccd)]\n",
+ "smiles_strs = split_entries(ligand_smiles) # case-sensitive: leave as typed\n",
+ "\n",
+ "# Build AF3 chain entities (IDs A, B, C, ... in canonical order)\n",
+ "CHAIN_IDS = list('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')\n",
+ "chains, prot_groups, idx = [], {}, 0\n",
+ "\n",
+ "for seq in prot_seqs:\n",
+ " cid = CHAIN_IDS[idx]; idx += 1\n",
+ " if seq in prot_groups: # merge identical seqs -> homo-oligomer\n",
+ " ent = prot_groups[seq]\n",
+ " ids = ent['id'] if isinstance(ent['id'], list) else [ent['id']]\n",
+ " ent['id'] = ids + [cid]\n",
+ " else:\n",
+ " ent = {'id': cid, 'sequence': seq, 'templates': []}\n",
+ " if msa_mode == 'single_sequence':\n",
+ " ent.update({'unpairedMsa': f'>query\\n{seq}\\n', 'pairedMsa': ''})\n",
+ " prot_groups[seq] = ent\n",
+ " chains.append({'protein': ent})\n",
+ "\n",
+ "for seq in rna_seqs:\n",
+ " c = {'id': CHAIN_IDS[idx], 'sequence': seq}\n",
+ " if msa_mode == 'single_sequence':\n",
+ " c['unpairedMsa'] = f'>query\\n{seq}\\n'\n",
+ " chains.append({'rna': c}); idx += 1\n",
+ "\n",
+ "for seq in dna_seqs:\n",
+ " chains.append({'dna': {'id': CHAIN_IDS[idx], 'sequence': seq}}); idx += 1\n",
+ "\n",
+ "for code in ccd_codes:\n",
+ " chains.append({'ligand': {'id': CHAIN_IDS[idx], 'ccdCodes': [code]}}); idx += 1\n",
+ "\n",
+ "for smiles in smiles_strs:\n",
+ " chains.append({'ligand': {'id': CHAIN_IDS[idx], 'smiles': smiles}}); idx += 1\n",
+ "\n",
+ "if not chains:\n",
+ " raise ValueError('No valid input found - fill in at least one box.')\n",
+ "\n",
+ "# Seeds: pull out integers regardless of separators, dedupe, default to [1]\n",
+ "seed_list = []\n",
+ "for tok in re.findall(r'\\d+', seeds):\n",
+ " v = int(tok)\n",
+ " if v not in seed_list:\n",
+ " seed_list.append(v)\n",
+ "if not seed_list:\n",
+ " seed_list = [1]\n",
+ "\n",
+ "# Deterministic, lower-cased job name from inputs+seeds.\n",
+ "# Same input+seeds -> same folder (so re-runs reuse it instead of piling up).\n",
+ "# Lower-cased to match run_alphafold.py's sanitised_name() output directory.\n",
+ "def _flat(mol):\n",
+ " if 'sequence' in mol: return mol['sequence']\n",
+ " if 'ccdCodes' in mol: return ','.join(mol['ccdCodes'])\n",
+ " return mol.get('smiles', '?')\n",
+ "flat = ':'.join(_flat(list(c.values())[0]) for c in chains) + '|seeds=' + ','.join(map(str, seed_list))\n",
+ "basejob = (re.sub(r'\\W+', '', ''.join(jobname.split())) or 'job').lower()\n",
+ "jobname = basejob + '_' + hashlib.sha1(flat.encode()).hexdigest()[:5]\n",
+ "\n",
+ "# Input JSON goes to a temp dir; ALL results land in ONE folder: af3_output/"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FLoa2lUhX9gu"
+ },
+ "source": [
+ "# **Biomolecular Emulator (BioEmu) in ColabFold**\n",
+ "![](\"https://github.com/microsoft/bioemu/raw/main/assets/emu.png\")
\n",
+ "\n",
+ "[BioEmu](https://github.com/microsoft/bioemu) is a framework for emulating biomolecular dynamics and integrating structural prediction tools to accelerate research in structural biology and protein engineering. This notebook uses BioEmu with ColabFold to generate the MSA and identify cluster conformations using Foldseek.\n",
+ "\n",
+ "\n",
+ "\n",
+ "For more details, please read the [BioEmu Preprint](https://www.biorxiv.org/content/10.1101/2024.12.05.626885v2).\n",
+ "\n",
+ "\n",
+ "## To run\n",
+ "Either run each cell sequentially, or click on `Runtime -> Run All` after choosing the desired sampling config"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "TWM2qzfEYMaL"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Sample with following config\n",
+ "#@markdown - `sequence`: Monomer sequence to sample\n",
+ "sequence = \"MADQLTEEQIAEFKEAFSLFDKDGDGTITTKELGTVMRSLGQNPTEAELQDMINEVDADGNGTIDFPEFLTMMARKMKDTDSEEEIREAFRVFDKDGNGYISAAELRHVMTNLGEKLTDEEVDEMIREADIDGDGQVNYEEFVQMMTAK\" #@param {type:\"string\"}\n",
+ "#@markdown - `num_samples`: Number of samples requested\n",
+ "num_samples = 10 #@param {type:\"integer\"}\n",
+ "#@markdown - `jobname`: Name assigned to this job\n",
+ "jobname = \"calmodulin\" #@param {type:\"string\"}\n",
+ "#@markdown - `filter_samples`: Whether to filter unphysical samples (e.g., those containing chain breaks) from the written samples\n",
+ "filter_samples = True #@param {type:\"boolean\"}\n",
+ "# #@param {type:\"boolean\"}\n",
+ "#@markdown - `model_name`: v1.1 = Journal accepted version | v1.0 preprint version\n",
+ "model_name = \"bioemu-v1.1\" #@param [\"bioemu-v1.0\", \"bioemu-v1.1\"]\n",
+ "# ------------------------\n",
+ "# Copied logic from ColabFold\n",
+ "# ------------------------\n",
+ "import os\n",
+ "import re\n",
+ "import hashlib\n",
+ "\n",
+ "def add_hash(x, seq):\n",
+ " \"\"\"Append a short SHA-1 hash of seq to x.\"\"\"\n",
+ " return x + \"_\" + hashlib.sha1(seq.encode()).hexdigest()[:5]\n",
+ "\n",
+ "def folder_is_free(folder):\n",
+ " \"\"\"Return True if folder doesn't exist.\"\"\"\n",
+ " return not os.path.exists(folder)\n",
+ "\n",
+ "jobname_clean = re.sub(r'\\W+', '', jobname)\n",
+ "sequence = \"\".join(sequence.split())\n",
+ "jobname = add_hash(jobname_clean, sequence)\n",
+ "\n",
+ "if not folder_is_free(jobname):\n",
+ " n = 0\n",
+ " while not folder_is_free(f\"{jobname}_{n}\"):\n",
+ " n += 1\n",
+ " jobname = f\"{jobname}_{n}\"\n",
+ "\n",
+ "output_dir = os.path.join(\"/content\", jobname)\n",
+ "os.makedirs(output_dir, exist_ok=True)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "7bAv6hU6Nedi",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Install dependencies\n",
+ "import os\n",
+ "import sys\n",
+ "\n",
+ "_is_bioemu_setup_file = '/content/.BIOEMU_SETUP'\n",
+ "\n",
+ "conda_prefix = '/usr/local/'\n",
+ "miniconda_link = 'https://repo.anaconda.com/miniconda/Miniconda3-py312_25.5.1-1-Linux-x86_64.sh'\n",
+ "miniconda_basename = os.path.basename(miniconda_link)\n",
+ "os.makedirs(conda_prefix, exist_ok=True)\n",
+ "\n",
+ "if not os.path.exists(_is_bioemu_setup_file):\n",
+ " os.system(f'wget {miniconda_link}')\n",
+ " os.system(f'chmod +x {miniconda_basename}')\n",
+ " os.system(f'./{miniconda_basename} -b -f -p {conda_prefix}')\n",
+ " os.system(f'conda install -q -y --prefix {conda_prefix} python=3.12')\n",
+ " os.system('uv pip install --prerelease if-necessary-or-explicit bioemu')\n",
+ "\n",
+ " os.system('conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main')\n",
+ " os.system('conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r')\n",
+ " os.system('conda install -c conda-forge openmm cuda-version=11 --yes')\n",
+ "\n",
+ " sys.path.append(os.path.join(conda_prefix, 'lib/python3.12/site-packages/'))\n",
+ "\n",
+ " os.environ['CONDA_PREFIX'] = conda_prefix\n",
+ " os.environ['CONDA_PREFIX_1'] = os.path.join(conda_prefix, 'envs/myenv')\n",
+ " os.environ['CONDA_DEFAULT_ENV'] = 'base'\n",
+ " os.system(f\"touch {_is_bioemu_setup_file}\")\n",
+ " os.system('wget https://mmseqs.com/foldseek/foldseek-linux-avx2.tar.gz; tar xvzf foldseek-linux-avx2.tar.gz')\n",
+ " os.system('/usr/bin/python3 -m pip install uv')\n",
+ " os.unlink(miniconda_basename)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "_TYvJwSLMpd7",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Run BioEmu\n",
+ "\n",
+ "from bioemu.sample import main as sample\n",
+ "output_dir = f'/content/{jobname}'\n",
+ "sample(sequence=sequence, num_samples=num_samples, model_name=model_name, output_dir=output_dir, filter_samples=filter_samples)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-1n_y3ycRpl4"
+ },
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "collapsed": true,
+ "id": "GbNRxHwgWzfF"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Write samples and run `foldseek`\n",
+ "#@markdown - `n_write_samples`: Number of samples to randomly select for clustering. Set to `-1` to select all available samples\n",
+ "#@markdown - `tmscore_threshold`: TM-score threshold used for foldseek clustering\n",
+ "#@markdown - `coverage_threshold`: Coverage threshold used for foldseek clustering\n",
+ "#@markdown - `seq_id`: Sequence identity threshold used for foldseek clustering\n",
+ "\n",
+ "n_write_samples = -1 #@param {type:\"integer\"}\n",
+ "tmscore_threshold = 0.6 #@param {type: \"number\"}\n",
+ "coverage_threshold = 0.7 #@param {type: \"number\"}\n",
+ "seq_id = 0.95 #@param {type: \"number\"}\n",
+ "\n",
+ "import numpy as np\n",
+ "import mdtraj\n",
+ "\n",
+ "_py3dmol_installed_file = '/content/.py3dmol'\n",
+ "if not os.path.exists(_py3dmol_installed_file):\n",
+ " os.system('uv pip install py3Dmol')\n",
+ " os.system(f\"touch {_py3dmol_installed_file}\")\n",
+ "\n",
+ "import py3Dmol\n",
+ "pdb_sample_dir = os.path.join('/content', 'pdb_samples')\n",
+ "os.makedirs(pdb_sample_dir, exist_ok=True)\n",
+ "\n",
+ "def write_some_samples(topology_file: str, trajectory_file: str, output_dir:str, n_samples: int) -> None:\n",
+ " traj = mdtraj.load(trajectory_file, top=topology_file)\n",
+ " assert traj.n_frames >= n_samples\n",
+ " if n_samples == -1:\n",
+ " sample_indices = np.arange(traj.n_frames)\n",
+ " else:\n",
+ " sample_indices = np.random.choice(np.arange(traj.n_frames), size=n_samples, replace=False)\n",
+ " for idx in sample_indices:\n",
+ " traj[idx].save_pdb(os.path.join(output_dir, f'sample_{idx}.pdb'))\n",
+ "\n",
+ "\n",
+ "topology_file = os.path.join(output_dir, \"topology.pdb\")\n",
+ "trajectory_file = os.path.join(output_dir, \"samples.xtc\")\n",
+ "\n",
+ "write_some_samples(topology_file=topology_file,\n",
+ " trajectory_file=trajectory_file,\n",
+ " output_dir=pdb_sample_dir,\n",
+ " n_samples=n_write_samples)\n",
+ "\n",
+ "# Foldseek\n",
+ "import os\n",
+ "import subprocess\n",
+ "import tempfile\n",
+ "\n",
+ "import pandas as pd\n",
+ "\n",
+ "def parse_foldseek_cluster_results(cluster_table_path: str) -> dict[int, list[str]]:\n",
+ " \"\"\"\n",
+ " Parses the result of foldseek clustering\n",
+ "\n",
+ " Args:\n",
+ " cluster_table: path of the output cluster table from foldseek\n",
+ "\n",
+ " Returns:\n",
+ " Dictionary mapping cluster indices to members\n",
+ "\n",
+ " \"\"\"\n",
+ "\n",
+ " cluster_table = pd.read_csv(cluster_table_path, sep=r\"\\s+\", header=None)\n",
+ "\n",
+ " cluster_idx_to_members = {}\n",
+ "\n",
+ " for index, group in enumerate(cluster_table.groupby(0)):\n",
+ " cluster_idx_to_members[index] = sorted(list(group[1][1]))\n",
+ "\n",
+ " return cluster_idx_to_members\n",
+ "\n",
+ "\n",
+ "def foldseek_cluster(\n",
+ " input_dir: str,\n",
+ " out_prefix: str | None = None,\n",
+ " tmscore_threshold: float = 0.7,\n",
+ " coverage_threshold: float = 0.9,\n",
+ " seq_id: float = 0.7,\n",
+ " coverage_mode: int = 1,\n",
+ ") -> dict[int, set[str]]:\n",
+ " \"\"\"\n",
+ " Runs foldseek easy cluster\n",
+ "\n",
+ " Args:\n",
+ " input_dir (str): input directory with .cif or .pdb files\n",
+ " out_prefix (str | None): the prefix of the output files, if None a temporary directory will be used\n",
+ " tmscore_threshold (float): the tm-score threshold used for clustering\n",
+ " coverage_threshold (float): the coverage threshold used for clustering\n",
+ " seq_id (float): the sequence identity threshold used for clustering\n",
+ " coverage_mode (int): mode used by mmseqs/foldseek to compute coverage\n",
+ "\n",
+ " Returns:\n",
+ " Dictionary mapping cluster indices to members\n",
+ " \"\"\"\n",
+ "\n",
+ " with tempfile.TemporaryDirectory() as temp_dir:\n",
+ "\n",
+ " with tempfile.TemporaryDirectory() as temp_out_dir:\n",
+ " if out_prefix is None:\n",
+ " out_prefix = os.path.join(temp_out_dir, \"output\")\n",
+ "\n",
+ " res = subprocess.run(\n",
+ " \"/content/foldseek/bin/foldseek easy-cluster \"\n",
+ " + input_dir\n",
+ " + \" \"\n",
+ " + out_prefix\n",
+ " + \" \"\n",
+ " + temp_dir\n",
+ " + \" -c \"\n",
+ " + str(coverage_threshold)\n",
+ " + \" --min-seq-id \"\n",
+ " + str(seq_id)\n",
+ " + \" --tmscore-threshold \"\n",
+ " + str(tmscore_threshold)\n",
+ " + \" --cov-mode \"\n",
+ " + str(coverage_mode)\n",
+ " + \" --single-step-clustering\",\n",
+ " shell=True,\n",
+ " )\n",
+ " assert res.returncode == 0, \"Something went wrong with foldseek\"\n",
+ "\n",
+ " cluster_idx_to_members = parse_foldseek_cluster_results(out_prefix + \"_cluster.tsv\")\n",
+ "\n",
+ " return cluster_idx_to_members\n",
+ "\n",
+ "!chmod +x '/content/foldseek/bin/foldseek'\n",
+ "\n",
+ "# Get foldseek clusters\n",
+ "clusters = foldseek_cluster(input_dir=pdb_sample_dir, tmscore_threshold=tmscore_threshold,\n",
+ " coverage_threshold=coverage_threshold, seq_id=seq_id)\n",
+ "n_clusters = len(clusters)\n",
+ "print(f'{n_clusters} clusters detected')\n",
+ "\n",
+ "# Write foldseek clusters to output dir\n",
+ "import json\n",
+ "\n",
+ "with open(os.path.join(output_dir, 'foldseek_clusters.json'), 'w') as json_handle:\n",
+ " json.dump(clusters, json_handle)\n",
+ "\n",
+ "\n",
+ "# Write XTC with one sample per cluster only\n",
+ "cluster_trajs = []\n",
+ "for _cluster_idx, samples in clusters.items():\n",
+ " sample = list(samples)[0] # Choose first sample in cluster\n",
+ " pdb_file = os.path.join(pdb_sample_dir, f\"{sample}.pdb\")\n",
+ " traj = mdtraj.load_pdb(pdb_file)\n",
+ " cluster_trajs.append(traj)\n",
+ "joint_traj = mdtraj.join(cluster_trajs)\n",
+ "cluster_topology_file = os.path.join(output_dir, \"clustered_topology.pdb\")\n",
+ "cluster_trajectory_file = os.path.join(output_dir, \"clustered_samples.xtc\")\n",
+ "joint_traj[0].save_pdb(cluster_topology_file)\n",
+ "joint_traj.save_xtc(cluster_trajectory_file)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "fLWzZQYAcVzr"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Display structure\n",
+ "import os\n",
+ "import ipywidgets as widgets\n",
+ "import py3Dmol\n",
+ "from IPython.display import display, clear_output\n",
+ "\n",
+ "# Create interactive widgets for cluster and sample selection.\n",
+ "cluster_slider = widgets.IntSlider(\n",
+ " value=0,\n",
+ " min=0,\n",
+ " max=n_clusters - 1,\n",
+ " step=1,\n",
+ " description='Cluster No:',\n",
+ " continuous_update=False\n",
+ ")\n",
+ "sample_slider = widgets.IntSlider(\n",
+ " value=0,\n",
+ " min=0,\n",
+ " max=0, # will update based on the selected cluster\n",
+ " step=1,\n",
+ " description='Sample Idx:',\n",
+ " continuous_update=False\n",
+ ")\n",
+ "display(cluster_slider, sample_slider)\n",
+ "\n",
+ "# Function to visualize a PDB file using py3Dmol.\n",
+ "def show_pdb(pdb_file: str, show_sidechains: bool = False, show_mainchains: bool = True):\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js')\n",
+ " try:\n",
+ " with open(pdb_file, 'r') as f:\n",
+ " pdb_content = f.read()\n",
+ " except FileNotFoundError:\n",
+ " print(f\"File not found: {pdb_file}\")\n",
+ " return None\n",
+ " view.addModel(pdb_content, 'pdb')\n",
+ " view.setStyle({'cartoon': {'color': 'spectrum'}})\n",
+ "\n",
+ " if show_sidechains:\n",
+ " BB = ['C', 'O', 'N']\n",
+ " view.addStyle({'and': [{'resn': [\"GLY\", \"PRO\"], 'invert': True}, {'atom': BB, 'invert': True}]},\n",
+ " {'stick': {'colorscheme': \"WhiteCarbon\", 'radius': 0.3}})\n",
+ " view.addStyle({'and': [{'resn': \"GLY\"}, {'atom': 'CA'}]},\n",
+ " {'sphere': {'colorscheme': \"WhiteCarbon\", 'radius': 0.3}})\n",
+ " view.addStyle({'and': [{'resn': \"PRO\"}, {'atom': ['C', 'O'], 'invert': True}]},\n",
+ " {'stick': {'colorscheme': \"WhiteCarbon\", 'radius': 0.3}})\n",
+ " if show_mainchains:\n",
+ " BB = ['C', 'O', 'N', 'CA']\n",
+ " view.addStyle({'atom': BB}, {'stick': {'colorscheme': \"WhiteCarbon\", 'radius': 0.3}})\n",
+ "\n",
+ " view.zoomTo()\n",
+ " return view\n",
+ "\n",
+ "# Helper to update the sample slider's maximum value based on the selected cluster.\n",
+ "def update_sample_slider(cluster_no):\n",
+ " available_samples = list(clusters[cluster_no])\n",
+ " sample_slider.max = max(len(available_samples) - 1, 0)\n",
+ " # Reset sample_slider's value if it's out of range.\n",
+ " if sample_slider.value > sample_slider.max:\n",
+ " sample_slider.value = 0\n",
+ "\n",
+ "# Main function to update the viewer whenever widget values change.\n",
+ "def update_view(change=None):\n",
+ " cluster_no = cluster_slider.value\n",
+ " update_sample_slider(cluster_no)\n",
+ " available_samples = list(clusters[cluster_no])\n",
+ " sample_idx = sample_slider.value\n",
+ "\n",
+ " clear_output(wait=True)\n",
+ " display(cluster_slider, sample_slider)\n",
+ "\n",
+ " if sample_idx >= len(available_samples):\n",
+ " print(f\"Only {len(available_samples)} samples available in cluster {cluster_no}\")\n",
+ " return\n",
+ "\n",
+ " chosen_sample = available_samples[sample_idx]\n",
+ " pdb_path = os.path.join(\"pdb_samples\", f\"{chosen_sample}.pdb\")\n",
+ "\n",
+ " # Check if the file exists before attempting to open it.\n",
+ " if not os.path.exists(pdb_path):\n",
+ " print(f\"File not found: {pdb_path}\")\n",
+ " return\n",
+ "\n",
+ " print(f\"Displaying sample {sample_idx} from cluster {cluster_no}\")\n",
+ " view = show_pdb(pdb_path)\n",
+ " if view:\n",
+ " view.show()\n",
+ "\n",
+ "# Observe changes to the slider values.\n",
+ "cluster_slider.observe(update_view, names='value')\n",
+ "sample_slider.observe(update_view, names='value')\n",
+ "\n",
+ "# Trigger an initial update.\n",
+ "update_view()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "O5EhJTP3tzcJ",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "#@title (Optional) Reconstruct sidechains + Run MD relaxation\n",
+ "#@markdown - `reconstruct_sidechains`: whether to reconstruct sidechains via `hpacker`\n",
+ "#@markdown - `run_md`: check to run MD after sidechain reconstruction, otherwise only sidechain reconstruction is performed\n",
+ "#@markdown - `md_protocol`: `LOCAL_MINIMIZATION`: fast but only resolves local problems ; `NVT_EQUIL`: slow but might resolve more severe issues\n",
+ "#@markdown - `one_per_cluster`: Reconstruct sidechains / optionally run MD for only one sample within each foldseek cluster\n",
+ "\n",
+ "#@markdown **WARNING**: this step can be quite expensive depending on how many samples you have requested / sequence length. You may want to check the `one_per_cluster` option.\n",
+ "\n",
+ "\n",
+ "reconstruct_sidechains = True #@param {type: \"boolean\"}\n",
+ "run_md = True #@param {type:\"boolean\"}\n",
+ "one_per_cluster = True #@param {type:\"boolean\"}\n",
+ "md_protocol = \"LOCAL_MINIMIZATION\" #@param [\"LOCAL_MINIMIZATION\", \"NVT_EQUIL\"] {type:\"string\"}\n",
+ "import bioemu.sidechain_relax\n",
+ "bioemu.sidechain_relax.HPACKER_PYTHONBIN = os.path.join(conda_prefix, '/envs/hpacker/bin/python')\n",
+ "\n",
+ "from bioemu.sidechain_relax import main as sidechainrelax\n",
+ "from bioemu.sidechain_relax import MDProtocol\n",
+ "md_protocol = MDProtocol[md_protocol]\n",
+ "os.environ['CONDA_PREFIX_1'] = conda_prefix\n",
+ "\n",
+ "if one_per_cluster:\n",
+ " topology_file = cluster_topology_file\n",
+ " trajectory_file = cluster_trajectory_file\n",
+ "\n",
+ "prefix = 'hpacker-openmm'\n",
+ "if reconstruct_sidechains:\n",
+ " relaxed_dir = os.path.join(output_dir, prefix)\n",
+ " os.makedirs(relaxed_dir, exist_ok=True)\n",
+ " sidechainrelax(pdb_path=topology_file, xtc_path=trajectory_file,\n",
+ " outpath=relaxed_dir, prefix=prefix, md_protocol=md_protocol,\n",
+ " md_equil=run_md)\n",
+ " if run_md:\n",
+ " os.system(f'touch {relaxed_dir}/.RELAXED')\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "gpuType": "T4",
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/data/Boltz1.ipynb b/data/Boltz1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b5389d7bf70679014322fe54b1f27b372a65250b
--- /dev/null
+++ b/data/Boltz1.ipynb
@@ -0,0 +1,337 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "machine_shape": "hm",
+ "gpuType": "T4",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# This is a work-in-progress notebook for [Boltz](https://github.com/jwohlwend/boltz)\n",
+ "\n",
+ "⚠️ **Warning to Users:**\n",
+ "- **Alpha Version:** This notebook is currently under active development and is considered a beta version.\n",
+ "- **Usage at Your Own Risk:** Use this notebook at your own discretion and risk."
+ ],
+ "metadata": {
+ "id": "KNOrLaJFdiA-"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Input protein sequence(s), then hit `Runtime` -> `Run all`\n",
+ "from google.colab import files\n",
+ "import os\n",
+ "import re\n",
+ "import hashlib\n",
+ "import random\n",
+ "import requests\n",
+ "from string import ascii_uppercase\n",
+ "\n",
+ "# Function to add a hash to the jobname\n",
+ "def add_hash(x, y):\n",
+ " return x + \"_\" + hashlib.sha1(y.encode()).hexdigest()[:5]\n",
+ "\n",
+ "# User inputs\n",
+ "query_sequence = 'PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASKK' #@param {type:\"string\"}\n",
+ "#@markdown - Use `:` to specify inter-protein chainbreaks for **modeling complexes** (supports homo- and hetro-oligomers). For example **PI...SK:PI...SK** for a homodimer\n",
+ "ligand_input = 'N[C@@H](Cc1ccc(O)cc1)C(=O)O' #@param {type:\"string\"}\n",
+ "#@markdown - Use `:` to specify multiple ligands as smile strings\n",
+ "ligand_input_ccd = 'SAH' #@param {type:\"string\"}\n",
+ "#@markdown - Use `:` to specify multiple ligands as CCD codes (three-letter codes)\n",
+ "ligand_input_common_name = '' #@param {type:\"string\"}\n",
+ "#@markdown - Use `:` to specify multiple ligands with their common name (e.g. Aspirin; SMILES fetched from [PubChem](https://pubchem.ncbi.nlm.nih.gov) API)\n",
+ "dna_input = '' #@param {type:\"string\"}\n",
+ "#@markdown - Use `:` to specify multiple DNA sequences\n",
+ "jobname = 'test' #@param {type:\"string\"}\n",
+ "\n",
+ "# Clean up the query sequence and jobname\n",
+ "query_sequence = \"\".join(query_sequence.split())\n",
+ "ligand_input = \"\".join(ligand_input.split())\n",
+ "ligand_input_ccd = \"\".join(ligand_input_ccd.split())\n",
+ "ligand_input_common_name = \"\".join(ligand_input_common_name.split())\n",
+ "dna_input = \"\".join(dna_input.split())\n",
+ "basejobname = \"\".join(jobname.split())\n",
+ "basejobname = re.sub(r'\\W+', '', basejobname)\n",
+ "jobname = add_hash(basejobname, query_sequence)\n",
+ "\n",
+ "# Check if a directory with jobname exists\n",
+ "def check(folder):\n",
+ " return not os.path.exists(folder)\n",
+ "\n",
+ "if not check(jobname):\n",
+ " n = 0\n",
+ " while not check(f\"{jobname}_{n}\"):\n",
+ " n += 1\n",
+ " jobname = f\"{jobname}_{n}\"\n",
+ "\n",
+ "# Make directory to save results\n",
+ "os.makedirs(jobname, exist_ok=True)\n",
+ "\n",
+ "from string import ascii_uppercase\n",
+ "\n",
+ "# Split sequences on chain breaks\n",
+ "protein_sequences = query_sequence.strip().split(':') if query_sequence.strip() else []\n",
+ "ligand_sequences = ligand_input.strip().split(':') if ligand_input.strip() else []\n",
+ "ligand_sequences_ccd = ligand_input_ccd.strip().split(':') if ligand_input_ccd.strip() else []\n",
+ "ligand_sequences_common_name = ligand_input_common_name.strip().split(':') if ligand_input_common_name.strip() else []\n",
+ "dna_sequences = dna_input.strip().split(':') if dna_input.strip() else []\n",
+ "\n",
+ "def get_smiles(compound_name):\n",
+ " autocomplete_url = f\"https://pubchem.ncbi.nlm.nih.gov/rest/autocomplete/compound/{compound_name}/json?limit=1\"\n",
+ " autocomplete_response = requests.get(autocomplete_url)\n",
+ " if autocomplete_response.status_code != 200:\n",
+ " return None\n",
+ "\n",
+ " autocomplete_data = autocomplete_response.json()\n",
+ " if autocomplete_data.get(\"status\", {}).get(\"code\") != 0 or autocomplete_data.get(\"total\", 0) == 0:\n",
+ " return None\n",
+ "\n",
+ " suggested_compound = autocomplete_data.get(\"dictionary_terms\", {}).get(\"compound\", [])\n",
+ " if not suggested_compound:\n",
+ " return None\n",
+ " suggested_compound_name = suggested_compound[0]\n",
+ "\n",
+ " smiles_url = f\"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{suggested_compound_name}/property/CanonicalSMILES/JSON\"\n",
+ " smiles_response = requests.get(smiles_url)\n",
+ " if smiles_response.status_code != 200:\n",
+ " return None\n",
+ "\n",
+ " smiles_data = smiles_response.json()\n",
+ " properties = smiles_data.get(\"PropertyTable\", {}).get(\"Properties\", [])\n",
+ " if len(properties) == 0:\n",
+ " return None\n",
+ "\n",
+ " return properties[0].get(\"CanonicalSMILES\")\n",
+ "\n",
+ "smiles_cache = {}\n",
+ "for name in ligand_sequences_common_name:\n",
+ " if name not in smiles_cache:\n",
+ " smiles_cache[name] = get_smiles(name)\n",
+ " if smiles_cache[name] is not None:\n",
+ " print(f\"Mapped compound {name} to {smiles_cache[name]}\")\n",
+ "\n",
+ " if smiles_cache[name] is not None:\n",
+ " ligand_sequences.append(smiles_cache[name])\n",
+ "\n",
+ "# Initialize chain labels starting from 'A'\n",
+ "chain_labels = iter(ascii_uppercase)\n",
+ "\n",
+ "fasta_entries = []\n",
+ "csv_entries = []\n",
+ "chain_label_to_seq_id = {}\n",
+ "seq_to_seq_id = {}\n",
+ "seq_id_counter = 0 # Counter for unique sequences\n",
+ "\n",
+ "# Process protein sequences\n",
+ "for seq in protein_sequences:\n",
+ " seq = seq.strip()\n",
+ " if not seq:\n",
+ " continue # Skip empty sequences\n",
+ " chain_label = next(chain_labels)\n",
+ " # Check if sequence has been seen before\n",
+ " if seq in seq_to_seq_id:\n",
+ " seq_id = seq_to_seq_id[seq]\n",
+ " else:\n",
+ " seq_id = f\"{jobname}_{seq_id_counter}\"\n",
+ " seq_to_seq_id[seq] = seq_id\n",
+ " seq_id_counter += 1\n",
+ " # For CSV file (for ColabFold), add only unique sequences\n",
+ " csv_entries.append((seq_id, seq))\n",
+ " chain_label_to_seq_id[chain_label] = seq_id\n",
+ " # For FASTA file\n",
+ " msa_path = os.path.join(jobname, f\"{seq_id}.a3m\")\n",
+ " header = f\">{chain_label}|protein|{msa_path}\"\n",
+ " sequence = seq\n",
+ " fasta_entries.append((header, sequence))\n",
+ "\n",
+ "# Process ligand sequences (assumed to be SMILES strings)\n",
+ "for lig in ligand_sequences:\n",
+ " lig = lig.strip()\n",
+ " if not lig:\n",
+ " continue # Skip empty ligands\n",
+ " chain_label = next(chain_labels)\n",
+ " lig_type = 'smiles'\n",
+ " header = f\">{chain_label}|{lig_type}\"\n",
+ " sequence = lig\n",
+ " fasta_entries.append((header, sequence))\n",
+ "\n",
+ "# Process DNA sequences (NO MSA is generated)\n",
+ "for seq in dna_sequences:\n",
+ " seq = seq.strip()\n",
+ " if not seq:\n",
+ " continue # Skip empty sequences\n",
+ " chain_label = next(chain_labels)\n",
+ " lig_type = 'DNA'\n",
+ " header = f\">{chain_label}|{lig_type}\"\n",
+ " sequence = seq\n",
+ " fasta_entries.append((header, sequence))\n",
+ "\n",
+ "# Process ligand sequences (CCD codes)\n",
+ "for lig in ligand_sequences_ccd:\n",
+ " lig = lig.strip()\n",
+ " if not lig:\n",
+ " continue # Skip empty ligands\n",
+ " chain_label = next(chain_labels)\n",
+ " lig_type = 'ccd'\n",
+ " header = f\">{chain_label}|{lig_type}\"\n",
+ " sequence = lig.upper() # Ensure CCD codes are uppercase\n",
+ " fasta_entries.append((header, sequence))\n",
+ "\n",
+ "# Write the CSV file for ColabFold\n",
+ "queries_path = os.path.join(jobname, f\"{jobname}.csv\")\n",
+ "with open(queries_path, \"w\") as text_file:\n",
+ " text_file.write(\"id,sequence\\n\")\n",
+ " for seq_id, seq in csv_entries:\n",
+ " text_file.write(f\"{seq_id},{seq}\\n\")\n",
+ "\n",
+ "# Write the FASTA file\n",
+ "queries_fasta = os.path.join(jobname, f\"{jobname}.fasta\")\n",
+ "with open(queries_fasta, 'w') as f:\n",
+ " for header, sequence in fasta_entries:\n",
+ " f.write(f\"{header}\\n{sequence}\\n\")\n",
+ "\n",
+ "# Optionally, print the output for verification\n",
+ "#print(f\"Generated FASTA file '{queries_fasta}':\\n\")\n",
+ "#for header, sequence in fasta_entries:\n",
+ "# print(f\"{header}\\n{sequence}\\n\")\n"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "AcYvVeDESi2a"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "4eXNO1JJHYrB"
+ },
+ "outputs": [],
+ "source": [
+ "#@title Install dependencies\n",
+ "%%time\n",
+ "import os\n",
+ "if not os.path.isfile(\"COLABFOLD_READY\"):\n",
+ " print(\"installing colabfold...\")\n",
+ " os.system(\"pip install -q --no-warn-conflicts 'colabfold[alphafold-minus-jax] @ git+https://github.com/sokrypton/ColabFold'\")\n",
+ " if os.environ.get('TPU_NAME', False) != False:\n",
+ " os.system(\"pip uninstall -y jax jaxlib\")\n",
+ " os.system(\"pip install --no-warn-conflicts --upgrade dm-haiku==0.0.10 'jax[cuda12_pip]'==0.3.25 -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html\")\n",
+ " os.system(\"ln -s /usr/local/lib/python3.*/dist-packages/colabfold colabfold\")\n",
+ " os.system(\"ln -s /usr/local/lib/python3.*/dist-packages/alphafold alphafold\")\n",
+ " # hack to fix TF crash\n",
+ " os.system(\"rm -f /usr/local/lib/python3.*/dist-packages/tensorflow/core/kernels/libtfkernel_sobol_op.so /usr/local/lib/python3.*/dist-packages/tensorflow/lite/python/*/*.so\")\n",
+ " os.system(\"touch COLABFOLD_READY\")\n",
+ "\n",
+ "if not os.path.isfile(\"BOLZ_READY\"):\n",
+ " os.system(\"apt-get install -y aria2\")\n",
+ " os.system(\"pip install -q --no-warn-conflicts boltz\")\n",
+ " os.system(\"mkdir weights\")\n",
+ " os.system(\"aria2c -d weights -x8 -s8 https://colabfold.steineggerlab.workers.dev/boltz1.ckpt\")\n",
+ " os.system(\"aria2c -d weights -x8 -s8 https://colabfold.steineggerlab.workers.dev/ccd.pkl\")\n",
+ " os.system(\"touch BOLZ_READY\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Generate MSA with ColabFold\n",
+ "!colabfold_batch \"{queries_path}\" \"{jobname}\" --msa-only"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "4aFDR4IhRe6y"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Predict structure using boltz\n",
+ "!boltz predict --out_dir \"{jobname}\" \"{jobname}/{jobname}.fasta\" --cache weights"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "bgaBXxXtIAu9"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Download results\n",
+ "# Import necessary modules\n",
+ "import os\n",
+ "import zipfile\n",
+ "from google.colab import files\n",
+ "import glob\n",
+ "\n",
+ "# Ensure 'jobname' variable is defined\n",
+ "# jobname = 'test_abcde' # Uncomment and set if not already defined\n",
+ "\n",
+ "# Name of the zip file\n",
+ "zip_filename = f\"results_{jobname}.zip\"\n",
+ "\n",
+ "# Create a zip file and add the specified files without preserving directory structure\n",
+ "with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
+ " coverage_png_files = glob.glob(os.path.join(jobname, '*_coverage.png'))\n",
+ " a3m_files = glob.glob(os.path.join(jobname, '*.a3m'))\n",
+ " for file in coverage_png_files + a3m_files:\n",
+ " arcname = os.path.basename(file) # Use only the file name\n",
+ " zipf.write(file, arcname=arcname)\n",
+ "\n",
+ " cif_files = glob.glob(os.path.join(jobname, f'boltz_results_{jobname}', 'predictions', jobname, '*.cif'))\n",
+ " for file in cif_files:\n",
+ " arcname = os.path.basename(file) # Use only the file name\n",
+ " zipf.write(file, arcname=arcname)\n",
+ "\n",
+ " hparams_file = os.path.join(jobname, f'boltz_results_{jobname}', 'lightning_logs', 'version_0', 'hparams.yaml')\n",
+ " if os.path.exists(hparams_file):\n",
+ " arcname = os.path.basename(hparams_file) # Use only the file name\n",
+ " zipf.write(hparams_file, arcname=arcname)\n",
+ " else:\n",
+ " print(f\"Warning: {hparams_file} not found.\")\n",
+ "\n",
+ "# Download the zip file\n",
+ "files.download(zip_filename)\n"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "jdSBSTOpaULF"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/Contributing.md b/data/Contributing.md
new file mode 100644
index 0000000000000000000000000000000000000000..94656a06caabc204ecc3bea9bb3b7157a6529521
--- /dev/null
+++ b/data/Contributing.md
@@ -0,0 +1,98 @@
+# Contributing to colabfold and our alphafold fork
+
+Install poetry (once per machine). Please consult the [poetry docs](https://python-poetry.org/docs/), they are well written:
+
+```shell
+curl -sSL https://install.python-poetry.org | python3 -
+poetry config virtualenvs.in-project true
+```
+
+Clone and install the dependencies:
+
+```shell
+git clone https://github.com/sokrypton/ColabFold
+cd ColabFold
+poetry install -E alphafold
+```
+
+Activate the environment (everytime you want to run some python or install something):
+
+```shell
+source .venv/bin/activate
+```
+
+Install jax; You need to repeat after every `poetry install`/`poetry lock`/`poetry update` unfortunately:
+
+```shell
+pip install -q "jax[cuda]>=0.3.8,<0.4" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+```
+
+If you also want to modify our alphafold fork
+
+```shell
+git clone https://github.com/steineggerlab/alphafold
+pip install -e alphafold
+```
+
+## Edit a dependency
+
+Edit the corresponding `pyproject.toml`, then run `poetry lock --no-update` in the directory of the `pyproject.toml`.
+
+## Edit colabfold
+
+You can run the tests with
+
+```
+pytest tests
+```
+
+## Edit alphafold
+
+ * switch to the alphafold folder
+ * Make edits to alphafold
+ * With the `pip install -e` install, you can directly test them in colabfold
+ * Set the last digit of `version=` in setup.py one higher, e.g. to `2.1.1234`
+ * git commit and push as usual
+ * `git tag v2.1.1234 -m v2.1.1234`, make sure it's the correct number (if you don't have permission, ask one of the team to push the tag)
+ * `git push --tags`
+ * In colabfold: update the number of `alphafold-colabfold = { version = "` in pyproject.toml, commit and push
+
+# Colab dev setup
+
+While it's generally easier to edit locally, you can also test and develop directly in google colab.
+
+We clone to _directory to avoid python from importing from the directory.
+
+```
+%%bash
+
+pip install -U pip
+git clone https://github.com/sokrypton/Colabfold _colabfold
+pip install _colabfold
+# Unholy Hack: Use the files from our cloned git repository instead of installed copy
+site_packages=$(python -c 'import site; print(site.getsitepackages()[0])')
+rm -r ${site_packages}/colabfold
+ln -s $(pwd)/_colabfold/colabfold ${site_packages}/colabfold
+```
+
+If you also need to patch alphafold:
+
+```
+%%bash
+
+pip uninstall -y alphafold
+git clone https://github.com/sokrypton/alphafold _alphafold
+pip install -e ./_alphafold
+```
+
+After that, restart the runtime.
+
+When you changed a file in the `colabfold` package, you need to reload the modules you were using with `importlib.reload()`, e.g.
+
+```python
+import colabfold.batch
+import importlib
+
+importlib.reload(colabfold.batch)
+```
+
diff --git a/data/Dockerfile b/data/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..c9f2b632e26d6ca6424f0a47ae3470e5aebf3867
--- /dev/null
+++ b/data/Dockerfile
@@ -0,0 +1,56 @@
+ARG MMSEQS_HASH=archive/8cc5ce367b5638c4306c2d7cfc652dd099a4643f
+ARG downloader=${TARGETARCH}_downloader
+
+FROM scratch AS amd64_downloader
+ARG MMSEQS_HASH
+WORKDIR /opt/build
+ONBUILD ADD https://mmseqs.com/${MMSEQS_HASH}/mmseqs-linux-gpu.tar.gz .
+
+FROM scratch AS arm64_downloader
+ARG MMSEQS_HASH
+WORKDIR /opt/build
+ONBUILD ADD https://mmseqs.com/${MMSEQS_HASH}/mmseqs-linux-gpu-arm64.tar.gz .
+
+FROM $downloader AS downloader
+
+FROM debian:trixie-slim AS builder
+WORKDIR /opt/build
+COPY --from=downloader /opt/build/* .
+RUN mkdir binaries; \
+ for i in *.tar.gz; do \
+ if [ -e ${i} ]; then \
+ tar -xzvf ${i}; \
+ mv -f -- */bin/* binaries/; \
+ fi; \
+ done; \
+ chmod -R +x binaries;
+
+FROM debian:trixie-slim
+
+VOLUME cache
+ENV MPLBACKEND=Agg
+ENV MPLCONFIGDIR=/cache
+ENV XDG_CACHE_HOME=/cache
+ENV CONDA_VERSION=25.9.1-0
+
+RUN apt-get update; \
+ apt-get install -y wget git --no-install-suggests; \
+ rm -rf /var/lib/apt/lists/*;
+
+SHELL ["/bin/bash", "--login", "-x", "-c"]
+RUN wget -qnc https://github.com/conda-forge/miniforge/releases/download/${CONDA_VERSION}/Miniforge3-${CONDA_VERSION}-Linux-x86_64.sh; \
+ bash Miniforge3-${CONDA_VERSION}-Linux-x86_64.sh -bfp /usr/local; \
+ conda config --set auto_update_conda false; \
+ rm -f Miniforge3-${CONDA_VERSION}-Linux-x86_64.sh; \
+ conda install -y -c conda-forge -c bioconda kalign2=2.04 hhsuite=3.3.0; \
+ conda clean -afy; \
+ conda shell.bash hook;
+COPY --from=builder /opt/build/binaries/* /usr/local/bin/
+
+WORKDIR /app
+COPY . /app
+RUN pip install --no-cache-dir \
+ ".[alphafold,openmm]" \
+ "jax[cuda]<0.8" \
+ "openmm[cuda12]"; \
+ rm -rf /root/.cache/pip
\ No newline at end of file
diff --git a/data/ESMFold.ipynb b/data/ESMFold.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..5724a4cc6b0c17b06c3817c707cf4bf6032bf477
--- /dev/null
+++ b/data/ESMFold.ipynb
@@ -0,0 +1,345 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU",
+ "gpuClass": "standard"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#**ESMFold**\n",
+ "for more details see: [Github](https://github.com/facebookresearch/esm/tree/main/esm), [Preprint](https://www.biorxiv.org/content/10.1101/2022.07.20.500902v1)\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "- use \"/\" to specify chainbreaks, (eg. sequence=\"AAA/AAA\")\n",
+ "- for homo-oligomeric predictions, set copies > 1\n",
+ "- See [experimental notebook](https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/beta/ESMFold_advanced.ipynb) for more advanced options (like sampling).\n",
+ "\n",
+ "#### **Colab Limitations**\n",
+ "- For short monomeric proteins under the length 400, consider using [ESMFold API](https://esmatlas.com/resources?action=fold) (no need for GPU, super fast!)\n",
+ "- On Tesla T4 (typical free colab GPU), max total length ~ 900"
+ ],
+ "metadata": {
+ "id": "POQBeXf2Xoxo"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "boFQEwsNQ4Qt"
+ },
+ "outputs": [],
+ "source": [
+ "%%time\n",
+ "#@title install\n",
+ "#@markdown install ESMFold, OpenFold and download Params (~2min 30s)\n",
+ "version = \"1\" # @param [\"0\", \"1\"]\n",
+ "model_name = \"esmfold_v0.model\" if version == \"0\" else \"esmfold.model\"\n",
+ "import os, time\n",
+ "if not os.path.isfile(model_name):\n",
+ " # download esmfold params\n",
+ " os.system(\"apt-get install aria2 -qq\")\n",
+ " os.system(f\"aria2c -q -x 16 https://colabfold.steineggerlab.workers.dev/esm/{model_name} &\")\n",
+ "\n",
+ " if not os.path.isfile(\"finished_install\"):\n",
+ " # install libs\n",
+ " print(\"installing libs...\")\n",
+ " os.system(\"pip install -q omegaconf pytorch_lightning biopython ml_collections einops py3Dmol modelcif\")\n",
+ " os.system(\"pip install -q git+https://github.com/NVIDIA/dllogger.git\")\n",
+ "\n",
+ " print(\"installing openfold...\")\n",
+ " # install openfold\n",
+ " os.system(f\"pip install -q git+https://github.com/sokrypton/openfold.git\")\n",
+ "\n",
+ " print(\"installing esmfold...\")\n",
+ " # install esmfold\n",
+ " os.system(f\"pip install -q git+https://github.com/sokrypton/esm.git\")\n",
+ " os.system(\"touch finished_install\")\n",
+ "\n",
+ " # wait for Params to finish downloading...\n",
+ " while not os.path.isfile(model_name):\n",
+ " time.sleep(5)\n",
+ " if os.path.isfile(f\"{model_name}.aria2\"):\n",
+ " print(\"downloading params...\")\n",
+ " while os.path.isfile(f\"{model_name}.aria2\"):\n",
+ " time.sleep(5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title ##run **ESMFold**\n",
+ "%%time\n",
+ "from string import ascii_uppercase, ascii_lowercase\n",
+ "import hashlib, re, os\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "from jax.tree_util import tree_map\n",
+ "import matplotlib.pyplot as plt\n",
+ "from scipy.special import softmax\n",
+ "import gc\n",
+ "\n",
+ "def parse_output(output):\n",
+ " pae = (output[\"aligned_confidence_probs\"][0] * np.arange(64)).mean(-1) * 31\n",
+ " plddt = output[\"plddt\"][0,:,1]\n",
+ "\n",
+ " bins = np.append(0,np.linspace(2.3125,21.6875,63))\n",
+ " sm_contacts = softmax(output[\"distogram_logits\"],-1)[0]\n",
+ " sm_contacts = sm_contacts[...,bins<8].sum(-1)\n",
+ " xyz = output[\"positions\"][-1,0,:,1]\n",
+ " mask = output[\"atom37_atom_exists\"][0,:,1] == 1\n",
+ " o = {\"pae\":pae[mask,:][:,mask],\n",
+ " \"plddt\":plddt[mask],\n",
+ " \"sm_contacts\":sm_contacts[mask,:][:,mask],\n",
+ " \"xyz\":xyz[mask]}\n",
+ " return o\n",
+ "\n",
+ "def get_hash(x): return hashlib.sha1(x.encode()).hexdigest()\n",
+ "alphabet_list = list(ascii_uppercase+ascii_lowercase)\n",
+ "\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "jobname = re.sub(r'\\W+', '', jobname)[:50]\n",
+ "\n",
+ "sequence = \"GWSTELEKHREELKEFLKKEGITNVEIRIDNGRLEVRVEGGTERLKRFLEELRQKLEKKGYTVDIKIE\" #@param {type:\"string\"}\n",
+ "sequence = re.sub(\"[^A-Z:]\", \"\", sequence.replace(\"/\",\":\").upper())\n",
+ "sequence = re.sub(\":+\",\":\",sequence)\n",
+ "sequence = re.sub(\"^[:]+\",\"\",sequence)\n",
+ "sequence = re.sub(\"[:]+$\",\"\",sequence)\n",
+ "copies = 1 #@param {type:\"integer\"}\n",
+ "if copies == \"\" or copies <= 0: copies = 1\n",
+ "sequence = \":\".join([sequence] * copies)\n",
+ "num_recycles = 3 #@param [\"0\", \"1\", \"2\", \"3\", \"6\", \"12\", \"24\"] {type:\"raw\"}\n",
+ "chain_linker = 25\n",
+ "\n",
+ "ID = jobname+\"_\"+get_hash(sequence)[:5]\n",
+ "seqs = sequence.split(\":\")\n",
+ "lengths = [len(s) for s in seqs]\n",
+ "length = sum(lengths)\n",
+ "print(\"length\",length)\n",
+ "\n",
+ "u_seqs = list(set(seqs))\n",
+ "if len(seqs) == 1: mode = \"mono\"\n",
+ "elif len(u_seqs) == 1: mode = \"homo\"\n",
+ "else: mode = \"hetero\"\n",
+ "\n",
+ "if \"model\" not in dir() or model_name != model_name_:\n",
+ " if \"model\" in dir():\n",
+ " # delete old model from memory\n",
+ " del model\n",
+ " gc.collect()\n",
+ " if torch.cuda.is_available():\n",
+ " torch.cuda.empty_cache()\n",
+ "\n",
+ " model = torch.load(model_name, weights_only=False)\n",
+ " model.eval().cuda().requires_grad_(False)\n",
+ " model_name_ = model_name\n",
+ "\n",
+ "# optimized for Tesla T4\n",
+ "if length > 700:\n",
+ " model.set_chunk_size(64)\n",
+ "else:\n",
+ " model.set_chunk_size(128)\n",
+ "\n",
+ "torch.cuda.empty_cache()\n",
+ "output = model.infer(sequence,\n",
+ " num_recycles=num_recycles,\n",
+ " chain_linker=\"X\"*chain_linker,\n",
+ " residue_index_offset=512)\n",
+ "\n",
+ "pdb_str = model.output_to_pdb(output)[0]\n",
+ "output = tree_map(lambda x: x.cpu().numpy(), output)\n",
+ "ptm = output[\"ptm\"][0]\n",
+ "plddt = output[\"plddt\"][0,...,1].mean()\n",
+ "O = parse_output(output)\n",
+ "print(f'ptm: {ptm:.3f} plddt: {plddt:.3f}')\n",
+ "os.system(f\"mkdir -p {ID}\")\n",
+ "prefix = f\"{ID}/ptm{ptm:.3f}_r{num_recycles}_default\"\n",
+ "np.savetxt(f\"{prefix}.pae.txt\",O[\"pae\"],\"%.3f\")\n",
+ "with open(f\"{prefix}.pdb\",\"w\") as out:\n",
+ " out.write(pdb_str)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "CcyNpAvhTX6q"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title display (optional) {run: \"auto\"}\n",
+ "import py3Dmol\n",
+ "pymol_color_list = [\"#33ff33\",\"#00ffff\",\"#ff33cc\",\"#ffff00\",\"#ff9999\",\"#e5e5e5\",\"#7f7fff\",\"#ff7f00\",\n",
+ " \"#7fff7f\",\"#199999\",\"#ff007f\",\"#ffdd5e\",\"#8c3f99\",\"#b2b2b2\",\"#007fff\",\"#c4b200\",\n",
+ " \"#8cb266\",\"#00bfbf\",\"#b27f7f\",\"#fcd1a5\",\"#ff7f7f\",\"#ffbfdd\",\"#7fffff\",\"#ffff7f\",\n",
+ " \"#00ff7f\",\"#337fcc\",\"#d8337f\",\"#bfff3f\",\"#ff7fff\",\"#d8d8ff\",\"#3fffbf\",\"#b78c4c\",\n",
+ " \"#339933\",\"#66b2b2\",\"#ba8c84\",\"#84bf00\",\"#b24c66\",\"#7f7f7f\",\"#3f3fa5\",\"#a5512b\"]\n",
+ "\n",
+ "def show_pdb(pdb_str, show_sidechains=False, show_mainchains=False,\n",
+ " color=\"pLDDT\", chains=None, vmin=50, vmax=90,\n",
+ " size=(800,480), hbondCutoff=4.0,\n",
+ " Ls=None,\n",
+ " animate=False):\n",
+ "\n",
+ " if chains is None:\n",
+ " chains = 1 if Ls is None else len(Ls)\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js', width=size[0], height=size[1])\n",
+ " if animate:\n",
+ " view.addModelsAsFrames(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " else:\n",
+ " view.addModel(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " if color == \"pLDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':vmin,'max':vmax}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.zoomTo()\n",
+ " if animate: view.animate()\n",
+ " return view\n",
+ "\n",
+ "color = \"confidence\" #@param [\"confidence\", \"rainbow\", \"chain\"]\n",
+ "if color == \"confidence\": color = \"pLDDT\"\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "show_pdb(pdb_str, color=color,\n",
+ " show_sidechains=show_sidechains,\n",
+ " show_mainchains=show_mainchains,\n",
+ " Ls=lengths).show()"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "JM5ciSmeTZKO"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title plot confidence (optional)\n",
+ "\n",
+ "dpi = 100 #@param {type:\"integer\"}\n",
+ "\n",
+ "def plot_ticks(Ls):\n",
+ " Ln = sum(Ls)\n",
+ " L_prev = 0\n",
+ " for L_i in Ls[:-1]:\n",
+ " L = L_prev + L_i\n",
+ " L_prev += L_i\n",
+ " plt.plot([0,Ln],[L,L],color=\"black\")\n",
+ " plt.plot([L,L],[0,Ln],color=\"black\")\n",
+ " ticks = np.cumsum([0]+Ls)\n",
+ " ticks = (ticks[1:] + ticks[:-1])/2\n",
+ " plt.yticks(ticks,alphabet_list[:len(ticks)])\n",
+ "\n",
+ "def plot_confidence(O, Ls=None, dpi=100):\n",
+ " if \"lm_contacts\" in O:\n",
+ " plt.figure(figsize=(20,4), dpi=dpi)\n",
+ " plt.subplot(1,4,1)\n",
+ " else:\n",
+ " plt.figure(figsize=(15,4), dpi=dpi)\n",
+ " plt.subplot(1,3,1)\n",
+ "\n",
+ " plt.title('Predicted lDDT')\n",
+ " plt.plot(O[\"plddt\"])\n",
+ " if Ls is not None:\n",
+ " L_prev = 0\n",
+ " for L_i in Ls[:-1]:\n",
+ " L = L_prev + L_i\n",
+ " L_prev += L_i\n",
+ " plt.plot([L,L],[0,100],color=\"black\")\n",
+ " plt.xlim(0,O[\"plddt\"].shape[0])\n",
+ " plt.ylim(0,100)\n",
+ " plt.ylabel('plDDT')\n",
+ " plt.xlabel('position')\n",
+ " plt.subplot(1,4 if \"lm_contacts\" in O else 3,2)\n",
+ "\n",
+ " plt.title('Predicted Aligned Error')\n",
+ " Ln = O[\"pae\"].shape[0]\n",
+ " plt.imshow(O[\"pae\"],cmap=\"bwr\",vmin=0,vmax=30,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " plt.colorbar()\n",
+ " plt.xlabel('Scored residue')\n",
+ " plt.ylabel('Aligned residue')\n",
+ "\n",
+ " if \"lm_contacts\" in O:\n",
+ " plt.subplot(1,4,3)\n",
+ " plt.title(\"contacts from LM\")\n",
+ " plt.imshow(O[\"lm_contacts\"],cmap=\"Greys\",vmin=0,vmax=1,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " plt.subplot(1,4,4)\n",
+ " else:\n",
+ " plt.subplot(1,3,3)\n",
+ " plt.title(\"contacts from Structure Module\")\n",
+ " plt.imshow(O[\"sm_contacts\"],cmap=\"Greys\",vmin=0,vmax=1,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " return plt\n",
+ "\n",
+ "plot_confidence(O, Ls=lengths, dpi=dpi)\n",
+ "plt.savefig(f'{prefix}.png',bbox_inches='tight')\n",
+ "plt.show()"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "HGFBl0QYYQpR"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title download predictions\n",
+ "from google.colab import files\n",
+ "os.system(f\"zip {ID}.zip {ID}/*\")\n",
+ "files.download(f'{ID}.zip')"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "hkMp_ZwRYfAQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/LICENSE b/data/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..4aab10a667a13d810b86f6df1b61fa1a1bfc87dd
--- /dev/null
+++ b/data/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Sergey Ovchinnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/data/MsaServer/README.md b/data/MsaServer/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ec42e255c380d1c231160fb671f7f00cb8ffd313
--- /dev/null
+++ b/data/MsaServer/README.md
@@ -0,0 +1,65 @@
+# Setting up your local ColabFold API server
+
+Here you will find two examples of how to setup your own API server on a Linux (or macOS for testing) machine.
+
+## `setup-and-start-local.sh`
+
+The `setup-and-start-local.sh` script will execute most of the steps to get a server running for you.
+It will do the following steps:
+* check that all required software is installed (`curl`, `aria2c`, `rsync`, `aws`)
+* download pinned **MMseqs2** and **mmseqs-server** binaries for your platform (Linux x86\_64/arm64, macOS universal)
+* download the databases (UniRef30 and ColabFoldDB, this might take some time)
+* download the API server and compile its binary
+* start the API server
+
+The script can be called repeatedly to (re)start the server. It avoids unnecessary work and only re-downloads components when the pinned commit changed.
+
+### CPU/GPU and platform detection
+
+* Uncomment the `export GPU=1` line to enable GPU mode (Linux only).
+* The script adds the parameters `--paths.colabfold.gpu.gpu 1 --paths.colabfold.gpu.server 1`. See `config.json` for more details.
+
+### Choosing a PDB rsync mirror
+
+At the top of the script you can set the PDB mirror to use (RCSB, PDBe or PDBj).
+Uncomment the pair you want. The script exits if no mirror is selected.
+
+### Configuration
+
+Edit `config.json` as needed. Common tweaks:
+
+* `server.address` — change the bind address/port (we recommend putting `nginx` in front for gzip/SSL).
+* `local.workers` — number of local job workers.
+* Optional GPU block under `paths.colabfold.gpu` lets you pin device IDs per DB when you run multi-GPU.
+* A `server.ratelimit` example is included and can be enabled.
+
+### Run
+
+```
+./setup-and-start-local.sh
+```
+
+If `DEBUG_MINI_DB=1` is set, the server starts with templates disabled and a tiny DB for quick tests.
+
+## Setup a systemd service
+To better manage the ColabFold API server, we recommend to setup a systemd service. It will automatically restart on failure and lets you use `journalctl`/`systemctl`.
+
+1. First run `setup-and-start-local.sh` once to get the folder structure and binaries.
+2. Adjust the `systemd-example-mmseqs-server.service` example and point it to your paths:
+3. Enable and start `./restart-systemd.sh`
+
+## Forcing databases to stay resident in system memory
+
+The ColabFold MSA API server will only achieve response time of few seconds if the search database are held fully within system memory. We use vmtouch (https://github.com/hoytech/vmtouch) to keep the precomputed database index file within system memory. In CPU mode, this is the most expensive part of the MSA API server, as the two default databases (UniRef30+ColabFoldDB) require currently 768GB-1024GB RAM to stay resident in RAM and have enough RAM spare for worker processes.
+
+After installing `vmtouch`, you can execute the following command to make sure that the search databases are not evicted from the system cache:
+
+```
+cd databases
+sudo vmtouch -f -w -t -l -d -m 1000G *.idx
+```
+
+## Using a custom API server
+
+You can pass the server URL to `colabfold_batch` via `--host-url`.
+In notebooks, add `host_url=https://yourserver.example.org` to the `run()` call in the *Run Prediction* cell.
diff --git a/data/MsaServer/config.json b/data/MsaServer/config.json
new file mode 100644
index 0000000000000000000000000000000000000000..1fce66fc0ab619e7013b49a83e0c9c6554c61832
--- /dev/null
+++ b/data/MsaServer/config.json
@@ -0,0 +1,112 @@
+{
+ "app": "colabfold",
+ // should mmseqs und webserver output be printed
+ "verbose": true,
+ "server" : {
+ "address" : "127.0.0.1:8080",
+ // prefix for all API endpoints
+ "pathprefix" : "/api/",
+ // enables additional API endpoints for adding databases
+ // WARNING: No additional authentication provided. Enable only within trusted network/for trusted admins.
+ "dbmanagment": false,
+ /* enable HTTP Basic Auth (optional)
+ "auth": {
+ "username" : "",
+ "password" : "",
+ },
+ // enable rate-limiting (optional)
+ "ratelimit" : {
+ // this uses the token-bucket algorithm
+ // i.e. we start with a full bucket (with burst tokens) and refill it at a given rate
+ // each request consumes one token, if the bucket is empty the request is rejected
+ // the example below starts with 20 tokens and refills 0.0333 token per second (2 tokens per minute)
+ "rate" : 0.03333333333333,
+ "burst" : 20,
+ "ttl" : 1,
+ "reason" : "The foldseek server is a shared resource. Please be mindful about submitting many jobs.",
+ // CIDRs to allow without rate-limiting
+ "allowlist": [],
+ },
+ */
+ // should CORS headers be set to allow requests from anywhere
+ "cors" : true,
+ // should old jobs be checked on startup
+ "checkold" : true,
+ },
+ "worker": {
+ // should workers exit immediately after SIGINT/SIGTERM signal or gracefully wait for job completion
+ "gracefulexit": false,
+ // How many databases can be searched in parallel (uses additional CPUs)
+ "paralleldatabases": 1,
+ },
+ // paths to workfolders and mmseqs, special character ~ is resolved relative to the binary location
+ "paths" : {
+ // path to job results and scratch directory, has to be shared between server/workers
+ "results" : "~jobs",
+ // paths to colabfold templates
+ "colabfold" : {
+ // configure GPU support for colabfold
+ // GPU support for mmseqs and foldseek is configured in database .params files
+ /*
+ "gpu" : {
+ // enable/disable
+ "gpu": true,
+ // enable gpuserver, saves about 1.5s per request in overhead
+ "server": true,
+ // set cuda visible devices for all databases, can be empty/omitted
+ // "devices": "0,1,2",
+ // set/override devices per database for better VRAM managment
+ // "uniref_devices": "0",
+ // "pdb_devices": "1",
+ // "environmental_devices": "2",
+ },
+ */
+ // should stages be run in parallel, faster at the cost of more CPU
+ "parallelstages": false,
+ // paths for search databases
+ "uniref" : "~databases/uniref30_2302_db",
+ "pdb" : "~databases/pdb100_230517",
+ "environmental" : "~databases/colabfold_envdb_202108_db",
+ // not used in public MSA server
+ // "environmentalpair" : "~databases/spire_ctg10_2401_db",
+ // paths for templates
+ "pdb70" : "~databases/pdb100",
+ "pdbdivided" : "~databases/pdb/divided",
+ "pdbobsolete" : "~databases/pdb/obsolete",
+ },
+ // path to mmseqs binary
+ "mmseqs" : "mmseqs",
+ },
+ // connection details for redis database, not used in -local mode
+ "redis" : {
+ "network" : "tcp",
+ "address" : "localhost:6379",
+ "password" : "",
+ "index" : 0,
+ },
+ // options for local/single-binary server
+ "local" : {
+ "workers" : 1,
+ // should old jobs be checked on startup
+ "checkold" : true,
+ },
+ "mail" : {
+ "type" : "null",
+ "sender" : "mail@example.org",
+ "templates" : {
+ "success" : {
+ "subject" : "Done -- %s",
+ "body" : "Dear User,\nThe results of your submitted job are available now at https://search.mmseqs.com/queue/%s .\n"
+ },
+ "timeout" : {
+ "subject" : "Timeout -- %s",
+ "body" : "Dear User,\nYour submitted job timed out. More details are available at https://search.mmseqs.com/queue/%s .\nPlease adjust the job and submit it again.\n"
+ },
+ "error" : {
+ "subject" : "Error -- %s",
+ "body" : "Dear User,\nYour submitted job failed. More details are available at https://search.mmseqs.com/queue/%s .\nPlease submit your job later again.\n"
+ }
+ }
+ }
+}
+
diff --git a/data/MsaServer/restart-systemd.sh b/data/MsaServer/restart-systemd.sh
new file mode 100644
index 0000000000000000000000000000000000000000..71d10c0865ecc4b8691ef894e4061a8412025a8c
--- /dev/null
+++ b/data/MsaServer/restart-systemd.sh
@@ -0,0 +1,5 @@
+#!/bin/sh -e
+sudo systemctl stop mmseqs-server
+rm -rf -- jobs
+mkdir -p jobs
+sudo systemctl start mmseqs-server
diff --git a/data/MsaServer/setup-and-start-local.sh b/data/MsaServer/setup-and-start-local.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9da4d17f7a0a62e6e99be84daad57c884e635a0d
--- /dev/null
+++ b/data/MsaServer/setup-and-start-local.sh
@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+set -e
+
+# run this script from the MsaServer folder
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+cd "${SCRIPT_DIR}"
+
+# enable this if you want to start a GPU MSA server
+#export GPU=1
+
+# choose which pdb rsync server to use
+#PDB_SERVER=rsync.wwpdb.org::ftp # RCSB PDB server name
+#PDB_PORT=33444 # port RCSB PDB server is using
+#
+#PDB_SERVER=rsync.ebi.ac.uk::pub/databases/rcsb/pdb-remediated # PDBe server name
+#PDB_PORT=873 # port PDBe server is using
+#
+#PDB_SERVER=pdb.protein.osaka-u.ac.jp::ftp # PDBj server name
+#PDB_PORT=873 # port PDBj server is using
+if [ -z "${PDB_SERVER}" ] || [ -z "${PDB_PORT}" ]; then
+ echo "PDB rsync server was not chosen, please edit this script to choose which PDB download server you want to use"
+ exit 1
+fi
+
+# set which commits to use
+MMSEQS_COMMIT=${1:-05ae20cbc628d9911ad0aa421fba029cc457b76e}
+BACKEND_COMMIT=${2:-01365aa4735539ba95b417f73fb5326c77410394}
+
+# check if all dependencies are there
+for i in curl aria2c rsync aws; do
+ if ! command -v "${i}" > /dev/null 2>&1; then
+ echo "${i} is not installed, please install it first"
+ exit 1
+ fi
+done
+
+ARCH=avx2
+if [ -n "${GPU}" ]; then
+ ARCH=gpu
+fi
+ARCH_SERVER=x86_64;
+case "$(uname -m)" in
+ aarch64|arm64)
+ ARCH=arm64
+ if [ -n "${GPU}" ]; then
+ ARCH=gpu-arm64
+ fi
+ ARCH_SERVER=arm64
+ ;;
+esac
+
+OS=linux
+case "$(uname -s)" in
+ Darwin)
+ OS=osx
+ ARCH=universal
+ ARCH_SERVER=universal
+ unset GPU
+ ;;
+esac
+
+# check that the correct mmseqs commit is there
+if [ -x ./mmseqs/bin/mmseqs ]; then
+ # download it again if its a different commit
+ if [ $(./mmseqs/bin/mmseqs version) != ${MMSEQS_COMMIT} ]; then
+ rm -rf -- mmseqs
+ curl -s -o- https://mmseqs.com/archive/${MMSEQS_COMMIT}/mmseqs-${OS}-${ARCH}.tar.gz | tar -xzf - mmseqs/bin/mmseqs
+ fi
+else
+ curl -s -o- https://mmseqs.com/archive/${MMSEQS_COMMIT}/mmseqs-${OS}-${ARCH}.tar.gz | tar -xzf - mmseqs/bin/mmseqs
+fi
+
+# check that the correct mmseqs commit is there
+if [ -x ./mmseqs-server/bin/mmseqs-server ]; then
+ # download it again if its a different commit
+ if [ $(./mmseqs-server/bin/mmseqs-server -version) != ${BACKEND_COMMIT} ]; then
+ rm -rf -- mmseqs-server
+ curl -s -o- https://mmseqs.com/archive/${BACKEND_COMMIT}/mmseqs-server-${OS}-${ARCH_SERVER}.tar.gz | tar -xzf - mmseqs-server/bin/mmseqs-server
+ fi
+else
+ curl -s -o- https://mmseqs.com/archive/${BACKEND_COMMIT}/mmseqs-server-${OS}-${ARCH_SERVER}.tar.gz | tar -xzf - mmseqs-server/bin/mmseqs-server
+fi
+
+
+# mmseqs needs to be in PATH for the setup_databases script to work
+PATH="${SCRIPT_DIR}/mmseqs/bin:$PATH"
+
+# This downloads a tiny swissprot based database for testing only
+#export DEBUG_MINI_DB=1
+# don't re-download databases if they already exist as they are large
+if [ ! -d databases ]; then
+ mkdir -p databases
+ if [ -n "${DEBUG_MINI_DB}" ]; then
+ touch databases/SKIP_TEMPLATES
+ fi
+ ../setup_databases.sh databases "${PDB_SERVER}" "${PDB_PORT}"
+fi
+
+# Extra GPU parameters
+GPU_PARAMS=""
+if [ -n "${GPU}" ]; then
+ GPU_PARAMS="--paths.colabfold.gpu.gpu 1 --paths.colabfold.gpu.server 1"
+fi
+
+# start the server in local mode
+# meaning both workers and server run from the same process
+if [ -n "${DEBUG_MINI_DB}" ]; then
+ ./mmseqs-server/bin/mmseqs-server -local -config config.json -paths.colabfold.pdb70 '' ${GPU_PARAMS}
+else
+ ./mmseqs-server/bin/mmseqs-server -local -config config.json ${GPU_PARAMS}
+fi
diff --git a/data/MsaServer/systemd-example-mmseqs-server.service b/data/MsaServer/systemd-example-mmseqs-server.service
new file mode 100644
index 0000000000000000000000000000000000000000..5b944aabcb7c89307aaccc9ae709f572b2d01ebf
--- /dev/null
+++ b/data/MsaServer/systemd-example-mmseqs-server.service
@@ -0,0 +1,16 @@
+[Unit]
+Description=MMseqs2 Server
+After=network.target
+
+[Service]
+User=user
+Group=user
+WorkingDirectory=/path-to-mmseqs-server-home
+Environment="MMSEQS_NUM_THREADS=1"
+ExecStart=/path-to-mmseqs-server-home/msa-server -local -config /path-to-mmseqs-server-home/config.json
+Type=simple
+Restart=on-failure
+RestartSec=10s
+
+[Install]
+WantedBy=multi-user.target
diff --git a/data/README.md b/data/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a1066813421540a9bc9539ea2469283e5d0e547b
--- /dev/null
+++ b/data/README.md
@@ -0,0 +1,262 @@
+# ColabFold - v1.6.1
+
+For details of what was changed in v1.6.1, see [change log](https://github.com/sokrypton/ColabFold/wiki/v1.6.1)!
+
+
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "74RP4ByMFXHR"
+ },
+ "source": [
+ "# RoseTTAFold\n",
+ "**Limitations**\n",
+ "- This notebook disables a few aspects (templates, pytosetta) of the full rosettafold pipeline.\n",
+ "- For best resuls use the [full pipeline](https://github.com/RosettaCommons/RoseTTAFold) or [Robetta webserver](https://robetta.bakerlab.org/)!\n",
+ "- For a typical Google-Colab session, with a `16G-GPU`, the max total length is **700 residues**. Sometimes a `12G-GPU` is assigned, in which case the max length is lower.\n",
+ "- For version of RoseTTAFold that runs with pyRosetta [see here](https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/beta/RoseTTAFold.ipynb).\n",
+ "\n",
+ "For other related notebooks see [ColabFold](https://github.com/sokrypton/ColabFold)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "8v06TAo9ZaGH",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title ##Install and import libraries\n",
+ "#@markdown This step can take up to ~2 mins\n",
+ "\n",
+ "import os\n",
+ "import sys\n",
+ "from IPython.utils import io\n",
+ "from google.colab import files\n",
+ "\n",
+ "import torch\n",
+ "torch_v = torch.__version__\n",
+ "\n",
+ "\n",
+ "if not os.path.isdir(\"RoseTTAFold\"):\n",
+ " with io.capture_output() as captured:\n",
+ " # extra functionality\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\n",
+ "\n",
+ " # download model\n",
+ " %shell git clone https://github.com/RosettaCommons/RoseTTAFold.git\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/RoseTTAFold__network__Refine_module.patch\n",
+ " %shell patch -u RoseTTAFold/network/Refine_module.py -i RoseTTAFold__network__Refine_module.patch\n",
+ "\n",
+ " # download model params\n",
+ " %shell wget -qnc https://files.ipd.uw.edu/pub/RoseTTAFold/weights.tar.gz\n",
+ " %shell tar -xf weights.tar.gz\n",
+ " %shell rm weights.tar.gz\n",
+ "\n",
+ " # download scwrl4 (for adding sidechains)\n",
+ " # http://dunbrack.fccc.edu/SCWRL3.php\n",
+ " # Thanks Roland Dunbrack!\n",
+ " %shell wget -qnc https://files.ipd.uw.edu/krypton/TrRosetta/scwrl4.zip\n",
+ " %shell unzip -qqo scwrl4.zip\n",
+ "\n",
+ " # install libraries\n",
+ " %shell pip install -q dgl-cu113 -f https://data.dgl.ai/wheels/repo.html\n",
+ " %shell pip install -q torch-scatter -f https://pytorch-geometric.com/whl/torch-{torch_v}.html\n",
+ " %shell pip install -q torch-sparse -f https://pytorch-geometric.com/whl/torch-{torch_v}.html\n",
+ " %shell pip install -q torch-geometric\n",
+ " %shell pip install -q py3Dmol\n",
+ "\n",
+ "with io.capture_output() as captured:\n",
+ " sys.path.append('/content/RoseTTAFold/network')\n",
+ " import predict_e2e\n",
+ " from parsers import parse_a3m\n",
+ " \n",
+ "import colabfold as cf\n",
+ "import py3Dmol\n",
+ "import subprocess\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "def get_bfactor(pdb_filename):\n",
+ " bfac = []\n",
+ " for line in open(pdb_filename,\"r\"):\n",
+ " if line[:4] == \"ATOM\":\n",
+ " bfac.append(float(line[60:66]))\n",
+ " return np.array(bfac)\n",
+ "\n",
+ "def set_bfactor(pdb_filename, bfac):\n",
+ " I = open(pdb_filename,\"r\").readlines()\n",
+ " O = open(pdb_filename,\"w\")\n",
+ " for line in I:\n",
+ " if line[0:6] == \"ATOM \":\n",
+ " seq_id = int(line[22:26].strip()) - 1\n",
+ " O.write(f\"{line[:60]}{bfac[seq_id]:6.2f}{line[66:]}\")\n",
+ " O.close() \n",
+ "\n",
+ "def do_scwrl(inputs, outputs, exe=\"./scwrl4/Scwrl4\"):\n",
+ " subprocess.run([exe,\"-i\",inputs,\"-o\",outputs,\"-h\"],\n",
+ " stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)\n",
+ " bfact = get_bfactor(inputs)\n",
+ " set_bfactor(outputs, bfact)\n",
+ " return bfact"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "YWe2OSU59iKD",
+ "cellView": "form"
+ },
+ "source": [
+ "#@markdown ##Input Sequence\n",
+ "sequence = \"PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK\" #@param {type:\"string\"}\n",
+ "sequence = sequence.translate(str.maketrans('', '', ' \\n\\t')).upper()\n",
+ "\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "jobname = jobname+\"_\"+cf.get_hash(sequence)[:5]"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "_nTsyKtQxjO8",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Search against genetic databases\n",
+ "#@markdown ---\n",
+ "msa_method = \"mmseqs2\" #@param [\"mmseqs2\",\"single_sequence\",\"custom_a3m\"]\n",
+ "#@markdown - `mmseqs2` - FAST method from [ColabFold](https://github.com/sokrypton/ColabFold)\n",
+ "#@markdown - `single_sequence` - use single sequence input (not recommended, unless a *denovo* design and you dont expect to find any homologous sequences)\n",
+ "#@markdown - `custom_a3m` Upload custom MSA (a3m format)\n",
+ "\n",
+ "# tmp directory\n",
+ "prefix = cf.get_hash(sequence)\n",
+ "os.makedirs('tmp', exist_ok=True)\n",
+ "prefix = os.path.join('tmp',prefix)\n",
+ "\n",
+ "os.makedirs(jobname, exist_ok=True)\n",
+ "\n",
+ "\n",
+ "if msa_method == \"mmseqs2\":\n",
+ " a3m_lines = cf.run_mmseqs2(sequence, prefix, filter=True)\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(a3m_lines)\n",
+ "\n",
+ "elif msa_method == \"single_sequence\":\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(f\">{jobname}\\n{sequence}\\n\")\n",
+ "\n",
+ "elif msa_method == \"custom_a3m\":\n",
+ " print(\"upload custom a3m\")\n",
+ " msa_dict = files.upload()\n",
+ " lines = msa_dict[list(msa_dict.keys())[0]].decode().splitlines()\n",
+ " a3m_lines = []\n",
+ " for line in lines:\n",
+ " line = line.replace(\"\\x00\",\"\")\n",
+ " if len(line) > 0 and not line.startswith('#'):\n",
+ " a3m_lines.append(line)\n",
+ "\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(\"\\n\".join(a3m_lines))\n",
+ "\n",
+ "msa_all = parse_a3m(f\"{jobname}/msa.a3m\")\n",
+ "msa_arr = np.unique(msa_all,axis=0)\n",
+ "total_msa_size = len(msa_arr)\n",
+ "if msa_method == \"mmseqs2\":\n",
+ " print(f'\\n{total_msa_size} Sequences Found in Total (after filtering)\\n')\n",
+ "else:\n",
+ " print(f'\\n{total_msa_size} Sequences Found in Total\\n')\n",
+ "\n",
+ "if total_msa_size > 1:\n",
+ " plt.figure(figsize=(8,5),dpi=100)\n",
+ " plt.title(\"Sequence coverage\")\n",
+ " seqid = (msa_all[0] == msa_arr).mean(-1)\n",
+ " seqid_sort = seqid.argsort()\n",
+ " non_gaps = (msa_arr != 20).astype(float)\n",
+ " non_gaps[non_gaps == 0] = np.nan\n",
+ " plt.imshow(non_gaps[seqid_sort]*seqid[seqid_sort,None],\n",
+ " interpolation='nearest', aspect='auto',\n",
+ " cmap=\"rainbow_r\", vmin=0, vmax=1, origin='lower',\n",
+ " extent=(0, msa_arr.shape[1], 0, msa_arr.shape[0]))\n",
+ " plt.plot((msa_arr != 20).sum(0), color='black')\n",
+ " plt.xlim(0,msa_arr.shape[1])\n",
+ " plt.ylim(0,msa_arr.shape[0])\n",
+ " plt.colorbar(label=\"Sequence identity to query\",)\n",
+ " plt.xlabel(\"Positions\")\n",
+ " plt.ylabel(\"Sequences\")\n",
+ " plt.savefig(f\"{jobname}/msa_coverage.png\", bbox_inches = 'tight')\n",
+ " plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "14-q4hv59ast",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title ## Run RoseTTAFold for mainchain and Scrwl4 for sidechain prediction\n",
+ "\n",
+ "# load model\n",
+ "if \"rosettafold\" not in dir():\n",
+ " rosettafold = predict_e2e.Predictor(model_dir=\"weights\")\n",
+ "\n",
+ "# make prediction using model\n",
+ "rosettafold.predict(f\"{jobname}/msa.a3m\",f\"{jobname}/pred\")\n",
+ "\n",
+ "# pack sidechains using Scwrl4\n",
+ "plddt = do_scwrl(f\"{jobname}/pred.pdb\",f\"{jobname}/pred.scwrl.pdb\")\n",
+ "\n",
+ "print(f\"Predicted LDDT: {plddt.mean()}\")\n",
+ "\n",
+ "plt.figure(figsize=(8,5),dpi=100)\n",
+ "plt.plot(plddt)\n",
+ "plt.xlabel(\"positions\")\n",
+ "plt.ylabel(\"plddt\")\n",
+ "plt.ylim(0,1)\n",
+ "plt.savefig(f\"{jobname}/plddt.png\", bbox_inches = 'tight')\n",
+ "plt.show()\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "qPhmF8SZr1k8",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "color = \"lDDT\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "cf.show_pdb(f\"{jobname}/pred.scwrl.pdb\", show_sidechains, show_mainchains, color, chains=1, vmin=0.5, vmax=0.9).show()\n",
+ "\n",
+ "if color == \"lDDT\": cf.plot_plddt_legend().show() "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "j0RhMLHKHf8d",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Download prediction\n",
+ "\n",
+ "#@markdown Once this cell has been executed, a zip-archive with \n",
+ "#@markdown the obtained prediction will be automatically downloaded \n",
+ "#@markdown to your computer.\n",
+ "\n",
+ "# add settings file\n",
+ "settings_path = f\"{jobname}/settings.txt\"\n",
+ "with open(settings_path, \"w\") as text_file:\n",
+ " text_file.write(f\"method=RoseTTAFold\\n\")\n",
+ " text_file.write(f\"sequence={sequence}\\n\")\n",
+ " text_file.write(f\"msa_method={msa_method}\\n\")\n",
+ " text_file.write(f\"use_templates=False\\n\")\n",
+ "\n",
+ "# --- Download the predictions ---\n",
+ "!zip -q -r {jobname}.zip {jobname}\n",
+ "files.download(f'{jobname}.zip')"
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/RoseTTAFold2.ipynb b/data/RoseTTAFold2.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..2e3d5652a23e200408b52d3b1cf53b5d0405f083
--- /dev/null
+++ b/data/RoseTTAFold2.ipynb
@@ -0,0 +1,489 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "gpuType": "T4",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU",
+ "gpuClass": "standard"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "74RP4ByMFXHR"
+ },
+ "source": [
+ "#**RoseTTAFold2 (WIP)**\n",
+ "RoseTTAFold2 is a method for protein structure prediction.\n",
+ "\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "- use \":\" to specify multimeric input, (eg. sequence=\"AAA:AAA\")\n",
+ "- See detailed instructions at the end.\n",
+ "\n",
+ "\n",
+ "**NOTE:** This notebook is in active development, we are still working on adding all the options (such as template inputs) from the [manuscript](https://www.biorxiv.org/content/10.1101/2023.05.24.542179v1). Use at your own risk!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "%%time\n",
+ "#@title setup **RoseTTAFold2** (~1m)\n",
+ "params = \"RF2_apr23\" # @param [\"RF2_apr23\",\"RF2_jan24\"]\n",
+ "\n",
+ "import os, time, sys\n",
+ "os.environ[\"PYTORCH_CUDA_ALLOC_CONF\"] = \"max_split_size_mb:512\"\n",
+ "\n",
+ "if params == \"RF2_jan24\" and not os.path.isfile(f\"{params}.tgz\"):\n",
+ " # send param download into background\n",
+ " os.system(\"(apt-get install aria2; aria2c -q -x 16 https://files.ipd.uw.edu/dimaio/RF2_jan24.tgz) &\")\n",
+ "\n",
+ "if params == \"RF2_apr23\" and not os.path.isfile(f\"{params}.tgz\"):\n",
+ " # send param download into background\n",
+ " os.system(\"(apt-get install aria2; aria2c -q -x 16 https://files.ipd.uw.edu/dimaio/RF2_apr23.tgz) &\")\n",
+ "\n",
+ "if not os.path.isdir(\"RoseTTAFold2\"):\n",
+ " print(\"install RoseTTAFold2\")\n",
+ " os.system(\"git clone https://github.com/uw-ipd/RoseTTAFold2.git\")\n",
+ " os.system(\"pip install py3Dmol\")\n",
+ "\n",
+ " # 17Mar2024: adding --no-dependencies to avoid installing nvidia-cuda-* dependencies\n",
+ " # 25Aug2025: updating dgi install to work with latest pytorch\n",
+ " os.system(\"pip install --no-dependencies dgl -f https://data.dgl.ai/wheels/torch-2.4/cu124/repo.html\")\n",
+ " os.system(\"pip install --no-dependencies e3nn==0.5.5 opt_einsum_fx\")\n",
+ " os.system(\"cd RoseTTAFold2/SE3Transformer; pip install .\")\n",
+ "\n",
+ " os.system(\"wget https://raw.githubusercontent.com/sokrypton/ColabFold/main/colabfold/colabfold.py -O colabfold_utils.py\")\n",
+ "\n",
+ " #os.system(\"pip install dgl -f https://data.dgl.ai/wheels/cu121/repo.html\")\n",
+ " #os.system(\"cd RoseTTAFold2/SE3Transformer; pip -q install --no-cache-dir -r requirements.txt; pip -q install .\")\n",
+ " #os.system(\"wget https://raw.githubusercontent.com/sokrypton/ColabFold/beta/colabfold/mmseqs/api.py\")\n",
+ "\n",
+ " # install hhsuite\n",
+ " print(\"install hhsuite\")\n",
+ " os.makedirs(\"hhsuite\", exist_ok=True)\n",
+ " os.system(f\"curl -fsSL https://github.com/soedinglab/hh-suite/releases/download/v3.3.0/hhsuite-3.3.0-SSE2-Linux.tar.gz | tar xz -C hhsuite/\")\n",
+ "\n",
+ "if not os.path.isfile(f\"{params}.pt\"):\n",
+ " time.sleep(5)\n",
+ "\n",
+ "if os.path.isfile(f\"{params}.tgz.aria2\"):\n",
+ " print(\"downloading RoseTTAFold2 params\")\n",
+ " while os.path.isfile(f\"{params}.tgz.aria2\"):\n",
+ " time.sleep(5)\n",
+ "\n",
+ "if not os.path.isfile(f\"{params}.pt\"):\n",
+ " os.system(f\"tar -zxvf {params}.tgz\")\n",
+ " if params == \"RF2_apr23\":\n",
+ " os.system(f\"mv weights/{params}.pt .\")\n",
+ "\n",
+ "if not \"IMPORTED\" in dir():\n",
+ " if 'RoseTTAFold2/network' not in sys.path:\n",
+ " os.environ[\"DGLBACKEND\"] = \"pytorch\"\n",
+ " sys.path.append('RoseTTAFold2/network')\n",
+ " if \"hhsuite\" not in os.environ['PATH']:\n",
+ " os.environ['PATH'] += \":hhsuite/bin:hhsuite/scripts\"\n",
+ "\n",
+ " import matplotlib.pyplot as plt\n",
+ " from google.colab import files\n",
+ " import numpy as np\n",
+ " from parsers import parse_a3m\n",
+ " #from api import run_mmseqs2\n",
+ " from colabfold_utils import run_mmseqs2\n",
+ " import py3Dmol\n",
+ " import torch\n",
+ " from string import ascii_uppercase, ascii_lowercase\n",
+ " import hashlib, re, os\n",
+ " import random\n",
+ "\n",
+ " def get_hash(x): return hashlib.sha1(x.encode()).hexdigest()\n",
+ " alphabet_list = list(ascii_uppercase+ascii_lowercase)\n",
+ " from collections import OrderedDict, Counter\n",
+ "\n",
+ " IMPORTED = True\n",
+ "\n",
+ "if not \"pred\" in dir() or params_sele != params:\n",
+ " from predict import Predictor\n",
+ " print(\"compile RoseTTAFold2\")\n",
+ "\n",
+ " if (torch.cuda.is_available()):\n",
+ " pred = Predictor(f\"{params}.pt\", torch.device(\"cuda:0\"))\n",
+ " else:\n",
+ " print (\"WARNING: using CPU\")\n",
+ " pred = Predictor(f\"{params}.pt\", torch.device(\"cpu\"))\n",
+ " params_sele = params\n",
+ "\n",
+ "def get_unique_sequences(seq_list):\n",
+ " unique_seqs = list(OrderedDict.fromkeys(seq_list))\n",
+ " return unique_seqs\n",
+ "\n",
+ "def run_mmseqs2_wrapper(*args, **kwargs):\n",
+ " kwargs['user_agent'] = \"colabfold/rosettafold2\"\n",
+ " return run_mmseqs2(*args, **kwargs)\n",
+ "\n",
+ "def get_msa(seq, jobname, cov=50, id=90, max_msa=2048,\n",
+ " mode=\"unpaired_paired\"):\n",
+ "\n",
+ " assert mode in [\"unpaired\",\"paired\",\"unpaired_paired\"]\n",
+ " seqs = [seq] if isinstance(seq,str) else seq\n",
+ "\n",
+ " # collapse homooligomeric sequences\n",
+ " counts = Counter(seqs)\n",
+ " u_seqs = list(counts.keys())\n",
+ " u_nums = list(counts.values())\n",
+ "\n",
+ " # expand homooligomeric sequences\n",
+ " first_seq = \"/\".join(sum([[x]*n for x,n in zip(u_seqs,u_nums)],[]))\n",
+ " msa = [first_seq]\n",
+ "\n",
+ " path = os.path.join(jobname,\"msa\")\n",
+ " os.makedirs(path, exist_ok=True)\n",
+ " if mode in [\"paired\",\"unpaired_paired\"] and len(u_seqs) > 1:\n",
+ " print(\"getting paired MSA\")\n",
+ " out_paired = run_mmseqs2_wrapper(u_seqs, f\"{path}/\", use_pairing=True)\n",
+ " headers, sequences = [],[]\n",
+ " for a3m_lines in out_paired:\n",
+ " n = -1\n",
+ " for line in a3m_lines.split(\"\\n\"):\n",
+ " if len(line) > 0:\n",
+ " if line.startswith(\">\"):\n",
+ " n += 1\n",
+ " if len(headers) < (n + 1):\n",
+ " headers.append([])\n",
+ " sequences.append([])\n",
+ " headers[n].append(line)\n",
+ " else:\n",
+ " sequences[n].append(line)\n",
+ " # filter MSA\n",
+ " with open(f\"{path}/paired_in.a3m\",\"w\") as handle:\n",
+ " for n,sequence in enumerate(sequences):\n",
+ " handle.write(f\">n{n}\\n{''.join(sequence)}\\n\")\n",
+ " os.system(f\"hhfilter -i {path}/paired_in.a3m -id {id} -cov {cov} -o {path}/paired_out.a3m\")\n",
+ " with open(f\"{path}/paired_out.a3m\",\"r\") as handle:\n",
+ " for line in handle:\n",
+ " if line.startswith(\">\"):\n",
+ " n = int(line[2:])\n",
+ " xs = sequences[n]\n",
+ " # expand homooligomeric sequences\n",
+ " xs = ['/'.join([x]*num) for x,num in zip(xs,u_nums)]\n",
+ " msa.append('/'.join(xs))\n",
+ "\n",
+ " if len(msa) < max_msa and (mode in [\"unpaired\",\"unpaired_paired\"] or len(u_seqs) == 1):\n",
+ " print(\"getting unpaired MSA\")\n",
+ " out = run_mmseqs2_wrapper(u_seqs,f\"{path}/\")\n",
+ " Ls = [len(seq) for seq in u_seqs]\n",
+ " sub_idx = []\n",
+ " sub_msa = []\n",
+ " sub_msa_num = 0\n",
+ " for n,a3m_lines in enumerate(out):\n",
+ " sub_msa.append([])\n",
+ " with open(f\"{path}/in_{n}.a3m\",\"w\") as handle:\n",
+ " handle.write(a3m_lines)\n",
+ " # filter\n",
+ " os.system(f\"hhfilter -i {path}/in_{n}.a3m -id {id} -cov {cov} -o {path}/out_{n}.a3m\")\n",
+ " with open(f\"{path}/out_{n}.a3m\",\"r\") as handle:\n",
+ " for line in handle:\n",
+ " if not line.startswith(\">\"):\n",
+ " xs = ['-'*l for l in Ls]\n",
+ " xs[n] = line.rstrip()\n",
+ " # expand homooligomeric sequences\n",
+ " xs = ['/'.join([x]*num) for x,num in zip(xs,u_nums)]\n",
+ " sub_msa[-1].append('/'.join(xs))\n",
+ " sub_msa_num += 1\n",
+ " sub_idx.append(list(range(len(sub_msa[-1]))))\n",
+ "\n",
+ " while len(msa) < max_msa and sub_msa_num > 0:\n",
+ " for n in range(len(sub_idx)):\n",
+ " if len(sub_idx[n]) > 0:\n",
+ " msa.append(sub_msa[n][sub_idx[n].pop(0)])\n",
+ " sub_msa_num -= 1\n",
+ " if len(msa) == max_msa:\n",
+ " break\n",
+ "\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as handle:\n",
+ " for n,sequence in enumerate(msa):\n",
+ " handle.write(f\">n{n}\\n{sequence}\\n\")"
+ ],
+ "metadata": {
+ "id": "ymCHu14w17wF",
+ "cellView": "form"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title ###run **RoseTTAFold2**\n",
+ "sequence = \"PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK\" #@param {type:\"string\"}\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "\n",
+ "#@markdown symmetry settings\n",
+ "sym = \"X\" #@param [\"X\",\"C\", \"D\", \"T\", \"I\", \"O\"]\n",
+ "order = 1 #@param [\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"11\", \"12\"] {type:\"raw\"}\n",
+ "msa_concat_mode = \"diag\" #@param [\"diag\", \"repeat\", \"default\"]\n",
+ "\n",
+ "#@markdown msa settings\n",
+ "msa_method = \"mmseqs2\" #@param [\"mmseqs2\",\"single_sequence\",\"custom_a3m\"]\n",
+ "pair_mode = \"unpaired_paired\" #@param [\"unpaired_paired\",\"paired\",\"unpaired\"] {type:\"string\"}\n",
+ "collapse_identical = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "#@markdown RoseTTAFold2 settings\n",
+ "num_recycles = 6 #@param [0, 1, 3, 6, 12, 24] {type:\"raw\"}\n",
+ "\n",
+ "#@markdown stochastic settings\n",
+ "use_mlm = False #@param {type:\"boolean\"}\n",
+ "use_dropout = False #@param {type:\"boolean\"}\n",
+ "max_msa = 256 #@param [16, 32, 64, 128, 256, 512] {type:\"raw\"}\n",
+ "random_seed = 0 #@param {type:\"integer\"}\n",
+ "num_models = 1 #@param [\"1\", \"5\", \"10\", \"15\", \"20\", \"25\"] {type:\"raw\"}\n",
+ "\n",
+ "# process\n",
+ "max_extra_msa = max_msa * 8\n",
+ "\n",
+ "sequence = re.sub(\"[^A-Z:]\", \"\", sequence.replace(\"/\",\":\").upper())\n",
+ "sequence = re.sub(\":+\",\":\",sequence)\n",
+ "sequence = re.sub(\"^[:]+\",\"\",sequence)\n",
+ "sequence = re.sub(\"[:]+$\",\"\",sequence)\n",
+ "\n",
+ "if sym in [\"X\",\"C\"]:\n",
+ " copies = order\n",
+ "elif sym in [\"D\"]:\n",
+ " copies = order * 2\n",
+ "else:\n",
+ " copies = {\"T\":12,\"O\":24,\"I\":60}[sym]\n",
+ " order = \"\"\n",
+ "symm = sym + str(order)\n",
+ "\n",
+ "sequences = sequence.replace(\":\",\"/\").split(\"/\")\n",
+ "if collapse_identical:\n",
+ " u_sequences = get_unique_sequences(sequences)\n",
+ "else:\n",
+ " u_sequences = sequences\n",
+ "sequences = sum([u_sequences] * copies,[])\n",
+ "lengths = [len(s) for s in sequences]\n",
+ "\n",
+ "# TODO\n",
+ "#subcrop = 1000 if sum(lengths) > 1400 else -1\n",
+ "\n",
+ "subcrop = -1\n",
+ "topk = 1536\n",
+ "\n",
+ "\n",
+ "sequence = \"/\".join(sequences)\n",
+ "jobname = jobname+\"_\"+symm+\"_\"+get_hash(sequence)[:5]\n",
+ "\n",
+ "print(f\"jobname: {jobname}\")\n",
+ "print(f\"lengths: {lengths}\")\n",
+ "\n",
+ "os.makedirs(jobname, exist_ok=True)\n",
+ "if msa_method == \"mmseqs2\":\n",
+ " get_msa(u_sequences, jobname, mode=pair_mode, max_msa=max_extra_msa)\n",
+ "\n",
+ "elif msa_method == \"single_sequence\":\n",
+ " u_sequence = \"/\".join(u_sequences)\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(f\">{jobname}\\n{u_sequence}\\n\")\n",
+ "\n",
+ "elif msa_method == \"custom_a3m\":\n",
+ " print(\"upload custom a3m\")\n",
+ " msa_dict = files.upload()\n",
+ " lines = msa_dict[list(msa_dict.keys())[0]].decode().splitlines()\n",
+ " a3m_lines = []\n",
+ " for line in lines:\n",
+ " line = line.replace(\"\\x00\",\"\")\n",
+ " if len(line) > 0 and not line.startswith('#'):\n",
+ " a3m_lines.append(line)\n",
+ "\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(\"\\n\".join(a3m_lines))\n",
+ "\n",
+ "best_plddt = None\n",
+ "best_seed = None\n",
+ "for seed in range(random_seed,random_seed+num_models):\n",
+ " torch.manual_seed(seed)\n",
+ " random.seed(seed)\n",
+ " np.random.seed(seed)\n",
+ " npz = f\"{jobname}/rf2_seed{seed}_00.npz\"\n",
+ " pred.predict(inputs=[f\"{jobname}/msa.a3m\"],\n",
+ " out_prefix=f\"{jobname}/rf2_seed{seed}\",\n",
+ " symm=symm,\n",
+ " ffdb=None, #TODO (templates),\n",
+ " n_recycles=num_recycles,\n",
+ " msa_mask=0.15 if use_mlm else 0.0,\n",
+ " msa_concat_mode=msa_concat_mode,\n",
+ " nseqs=max_msa,\n",
+ " nseqs_full=max_extra_msa,\n",
+ " subcrop=subcrop,\n",
+ " topk=topk,\n",
+ " is_training=use_dropout)\n",
+ " plddt = np.load(npz)[\"lddt\"].mean()\n",
+ " if best_plddt is None or plddt > best_plddt:\n",
+ " best_plddt = plddt\n",
+ " best_seed = seed"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "Eh48KV70rQ03"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "color = \"plddt\" #@param [\"plddt\",\"chain\",\"rainbow\"]\n",
+ "import py3Dmol\n",
+ "import matplotlib\n",
+ "from string import ascii_uppercase,ascii_lowercase\n",
+ "alphabet_list = list(ascii_uppercase+ascii_lowercase)\n",
+ "pymol_color_list = [\"#33ff33\",\"#00ffff\",\"#ff33cc\",\"#ffff00\",\"#ff9999\",\"#e5e5e5\",\"#7f7fff\",\"#ff7f00\",\n",
+ " \"#7fff7f\",\"#199999\",\"#ff007f\",\"#ffdd5e\",\"#8c3f99\",\"#b2b2b2\",\"#007fff\",\"#c4b200\",\n",
+ " \"#8cb266\",\"#00bfbf\",\"#b27f7f\",\"#fcd1a5\",\"#ff7f7f\",\"#ffbfdd\",\"#7fffff\",\"#ffff7f\",\n",
+ " \"#00ff7f\",\"#337fcc\",\"#d8337f\",\"#bfff3f\",\"#ff7fff\",\"#d8d8ff\",\"#3fffbf\",\"#b78c4c\",\n",
+ " \"#339933\",\"#66b2b2\",\"#ba8c84\",\"#84bf00\",\"#b24c66\",\"#7f7f7f\",\"#3f3fa5\",\"#a5512b\"]\n",
+ "pymol_cmap = matplotlib.colors.ListedColormap(pymol_color_list)\n",
+ "\n",
+ "def plot_pdb(pdb, color=\"plddt\"):\n",
+ " hbondCutoff = 4.0\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js')\n",
+ " pdb_str = open(pdb,'r').read()\n",
+ " view.addModel(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " if color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,c in zip(range(len(lengths)),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':c}})\n",
+ " else:\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':50,'max':90}}})\n",
+ " view.zoomTo()\n",
+ " view.show()\n",
+ "\n",
+ "plot_pdb(f\"{jobname}/rf2_seed{best_seed}_00_pred.pdb\", color=color)\n",
+ "output = dict(np.load(f\"{jobname}/rf2_seed{best_seed}_00.npz\"))\n",
+ "plt.figure(figsize=(10,5))\n",
+ "plt.subplot(1,2,1)\n",
+ "plt.title(\"predicted LDDT\")\n",
+ "plt.plot(output[\"lddt\"])\n",
+ "plt.ylim(0,1.0)\n",
+ "plt.subplot(1,2,2)\n",
+ "plt.title(\"predicted alignment error\")\n",
+ "plt.imshow(output[\"pae\"],vmin=0,vmax=30,cmap=\"bwr\")\n",
+ "plt.show()"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "3m0H-yCIrpc4"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Download prediction\n",
+ "\n",
+ "#@markdown Once this cell has been executed, a zip-archive with\n",
+ "#@markdown the obtained prediction will be automatically downloaded\n",
+ "#@markdown to your computer.\n",
+ "\n",
+ "# add settings file\n",
+ "settings_path = f\"{jobname}/settings.txt\"\n",
+ "with open(settings_path, \"w\") as text_file:\n",
+ " text_file.write(f\"method=RoseTTAFold2\\n\")\n",
+ " text_file.write(f\"params={params}\\n\")\n",
+ " text_file.write(f\"sequence={sequence}\\n\")\n",
+ " text_file.write(f\"sym={sym}\\n\")\n",
+ " text_file.write(f\"order={order}\\n\")\n",
+ " text_file.write(f\"msa_concat_mode={msa_concat_mode}\\n\")\n",
+ " text_file.write(f\"collapse_identical={collapse_identical}\")\n",
+ " text_file.write(f\"random_seed={random_seed}\\n\")\n",
+ " text_file.write(f\"msa_method={msa_method}\\n\")\n",
+ " text_file.write(f\"num_recycles={num_recycles}\\n\")\n",
+ " text_file.write(f\"use_mlm={use_mlm}\\n\")\n",
+ " text_file.write(f\"use_dropout={use_dropout}\\n\")\n",
+ " text_file.write(f\"num_models={num_models}\\n\")\n",
+ "\n",
+ "# --- Download the predictions ---\n",
+ "os.system(f\"zip -r {jobname}.zip {jobname}\")\n",
+ "files.download(f'{jobname}.zip')"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "M21J9hQTLVhz"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#**Instructions**\n",
+ "---\n",
+ "**symmetry settings**\n",
+ "\n",
+ "RoseTTAFold2 was finetuned with explicit symmetry information. If the symmetry is known, you can specify using `sym` and `order` options. Supported symmetries include: [C]yclic, [D]ihedral, [T]etrahedral, [I]cosahedral, [O]ctahedral and [X] for unknown.\n",
+ "- `order` define number of copies in X/C/D symmetries.\n",
+ "- `msa_concat_mode` defines how the msa is concatenated.\n",
+ "```bash\n",
+ "| repeat | diag | default |\n",
+ "| AAA | A-- | A-- |\n",
+ "| | -A- | -AA |\n",
+ "| | --A | |\n",
+ "```\n",
+ "\n",
+ "**msa settings**\n",
+ "- `msa_method`\n",
+ " - `mmseqs2` - FAST method from [ColabFold](https://github.com/sokrypton/ColabFold)\n",
+ " - `single_sequence` - use single sequence input (not recommended, unless a *denovo* design and you dont expect to find any homologous sequences)\n",
+ " - `custom_a3m` Upload custom MSA (a3m format)\n",
+ "- `pair_mode` For multimeric inputs, specify how to generate MSA.\n",
+ " - `unpaired` - generate seperate MSA for each protein.\n",
+ " - `unpaired_paired` - attempt to pair sequences from the same genome.\n",
+ " - `paired` - only use sequences that were sucessfully paired.\n",
+ "- `collapse_identical` - remove identical (homooligomeric) sequences from input `sequence`. (This could be useful if you plan to use the symmetry option above).\n",
+ "\n",
+ "**RoseTTAFold2 settings**\n",
+ "- `num_recycles` specify number of iterations to run for.\n",
+ "\n",
+ "**stochastic settings**\n",
+ "\n",
+ " The stochasticity can be reproduced using specified `random_seed`. Increasing `num_models` controls how many random seeds to try: `range(random_seed,random_seed+num_models)`. There are 3 ways to introduce randomness into the predictions:\n",
+ "- `use_mlm` - random 15% of positions are masked in the input MSA.\n",
+ "- `use_dropout` - dropout layers are endabled during inference.\n",
+ "- `max_msa` - if `max_msa * 8` is lower than number of sequences in the input MSA. The number of sequences are subsampled to the max number. Different subsamplings may also results in stochasticity.\n",
+ "\n",
+ "**I'm running out of memory, what do I do??**\n",
+ "- Try decrease `max_msa` to a smaller number.\n",
+ "- Get better GPU, on free Google colab max total length ~1600"
+ ],
+ "metadata": {
+ "id": "IuRWdTAgY-7l"
+ }
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/batch/AlphaFold2_batch.ipynb b/data/batch/AlphaFold2_batch.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..bf4718a8d3b6ca7a411728fa17c4bb0554decaea
--- /dev/null
+++ b/data/batch/AlphaFold2_batch.ipynb
@@ -0,0 +1,277 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "name": "AlphaFold2_batch.ipynb",
+ "provenance": [],
+ "runtime_attributes": {
+ "runtime_version": "2025.07"
+ }
+ },
+ "kernelspec": {
+ "name": "python3",
+ "language": "python",
+ "display_name": "Python 3 (ipykernel)"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G4yBrceuFbf3"
+ },
+ "source": [
+ "#ColabFold v1.6.1: AlphaFold2 w/ MMseqs2 BATCH\n",
+ "\n",
+ "\n",
+ "\n",
+ "Easy to use AlphaFold2 protein structure [(Jumper et al. 2021)](https://www.nature.com/articles/s41586-021-03819-2) and complex [(Evans et al. 2021)](https://www.biorxiv.org/content/10.1101/2021.10.04.463034v1) prediction using multiple sequence alignments generated through MMseqs2. For details, refer to our manuscript:\n",
+ "\n",
+ "[Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold: Making protein folding accessible to all.\n",
+ "*Nature Methods*, 2022](https://www.nature.com/articles/s41592-022-01488-1)\n",
+ "\n",
+ "**Usage**\n",
+ "\n",
+ "`input_dir` directory with only fasta files or MSAs stored in Google Drive. MSAs need to be A3M formatted and have an `.a3m` extention. For MSAs MMseqs2 will not be called.\n",
+ "\n",
+ "`result_dir` results will be written to the result directory in Google Drive\n",
+ "\n",
+ "Old versions: [v1.4](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.4.0/batch/AlphaFold2_batch.ipynb), [v1.5.1](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.5.1/batch/AlphaFold2_batch.ipynb), [v1.5.2](https://colab.research.google.com/github/sokrypton/ColabFold/blob/v1.5.2/batch/AlphaFold2_batch.ipynb), [v1.5.3-patch](https://colab.research.google.com/github/sokrypton/ColabFold/blob/56c72044c7d51a311ca99b953a71e552fdc042e1/batch/AlphaFold2_batch.ipynb)\n",
+ "\n",
+ "For more details, see bottom of the notebook and checkout the [ColabFold GitHub](https://github.com/sokrypton/ColabFold). \n",
+ "\n",
+ "-----------\n",
+ "\n",
+ "### News\n",
+ "- 2023/07/31: The ColabFold MSA server is back to normal. It was using older DB (UniRef30 2202/PDB70 220313) from 27th ~8:30 AM CEST to 31st ~11:10 AM CEST.\n",
+ "- 2023/06/12: New databases! UniRef30 updated to 2023_02 and PDB to 230517. We now use PDB100 instead of PDB70 (see notes in the [main](https://colabfold.com) notebook).\n",
+ "- 2023/06/12: We introduced a new default pairing strategy: Previously, for multimer predictions with more than 2 chains, we only pair if all sequences taxonomically match (\"complete\" pairing). The new default \"greedy\" strategy pairs any taxonomically matching subsets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "AwvIWN3HDyUJ",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Mount google drive\n",
+ "from google.colab import drive\n",
+ "drive.mount('/content/drive')\n",
+ "from sys import version_info\n",
+ "python_version = f\"{version_info.major}.{version_info.minor}\""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kOblAo-xetgx",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Input protein sequence, then hit `Runtime` -> `Run all`\n",
+ "\n",
+ "input_dir = '/content/drive/MyDrive/input_fasta' #@param {type:\"string\"}\n",
+ "result_dir = '/content/drive/MyDrive/result' #@param {type:\"string\"}\n",
+ "\n",
+ "# number of models to use\n",
+ "#@markdown ---\n",
+ "#@markdown ### Advanced settings\n",
+ "msa_mode = \"MMseqs2 (UniRef+Environmental)\" #@param [\"MMseqs2 (UniRef+Environmental)\", \"MMseqs2 (UniRef only)\",\"single_sequence\",\"custom\"]\n",
+ "num_models = 5 #@param [1,2,3,4,5] {type:\"raw\"}\n",
+ "num_recycles = 3 #@param [1,3,6,12,24,48] {type:\"raw\"}\n",
+ "stop_at_score = 100 #@param {type:\"string\"}\n",
+ "#@markdown - early stop computing models once score > threshold (avg. plddt for \"structures\" and ptmscore for \"complexes\")\n",
+ "use_custom_msa = False\n",
+ "num_relax = 0 #@param [0, 1, 5] {type:\"raw\"}\n",
+ "use_amber = num_relax > 0\n",
+ "relax_max_iterations = 200 #@param [0,200,2000] {type:\"raw\"}\n",
+ "use_templates = False #@param {type:\"boolean\"}\n",
+ "do_not_overwrite_results = True #@param {type:\"boolean\"}\n",
+ "zip_results = False #@param {type:\"boolean\"}\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "iccGdbe_Pmt9",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Install dependencies\n",
+ "%%bash -s $use_amber $use_templates $python_version\n",
+ "\n",
+ "set -e\n",
+ "\n",
+ "USE_AMBER=$1\n",
+ "USE_TEMPLATES=$2\n",
+ "PYTHON_VERSION=$3\n",
+ "\n",
+ "if [ ! -f COLABFOLD_READY ]; then\n",
+ " # install dependencies\n",
+ " # We have to use \"--no-warn-conflicts\" because colab already has a lot preinstalled with requirements different to ours\n",
+ " pip install -q --no-warn-conflicts \"colabfold[alphafold-minus-jax] @ git+https://github.com/sokrypton/ColabFold\"\n",
+ " if [ -n \"${TPU_NAME}\" ]; then\n",
+ " pip install -q --no-warn-conflicts -U dm-haiku==0.0.10 jax==0.3.25\n",
+ " fi\n",
+ " ln -s /usr/local/lib/python3.*/dist-packages/colabfold colabfold\n",
+ " ln -s /usr/local/lib/python3.*/dist-packages/alphafold alphafold\n",
+ " # hack to fix TF crash\n",
+ " rm -f /usr/local/lib/python3.*/dist-packages/tensorflow/core/kernels/libtfkernel_sobol_op.so /usr/local/lib/python3.*/dist-packages/tensorflow/lite/python/*/*.so\n",
+ " touch COLABFOLD_READY\n",
+ "fi\n",
+ "\n",
+ "# Download params (~1min)\n",
+ "python -m colabfold.download\n",
+ "\n",
+ "# setup conda\n",
+ "if [ ${USE_AMBER} == \"True\" ] || [ ${USE_TEMPLATES} == \"True\" ]; then\n",
+ " if [ ! -f CONDA_READY ]; then\n",
+ " wget -qnc https://github.com/conda-forge/miniforge/releases/download/25.3.1-0/Miniforge3-25.3.1-0-Linux-x86_64.sh\n",
+ " bash Miniforge3-25.3.1-0-Linux-x86_64.sh -bfp /usr/local 2>&1 1>/dev/null\n",
+ " rm Miniforge3-25.3.1-0-Linux-x86_64.sh\n",
+ " conda config --set auto_update_conda false\n",
+ " touch CONDA_READY\n",
+ " fi\n",
+ "fi\n",
+ "# setup template search\n",
+ "if [ ${USE_TEMPLATES} == \"True\" ] && [ ! -f HH_READY ]; then\n",
+ " conda install -y -q -c conda-forge -c bioconda kalign2=2.04 hhsuite=3.3.0 python=\"${PYTHON_VERSION}\" 2>&1 1>/dev/null\n",
+ " touch HH_READY\n",
+ "fi\n",
+ "# setup openmm for amber refinement\n",
+ "if [ ${USE_AMBER} == \"True\" ] && [ ! -f AMBER_READY ]; then\n",
+ " conda install -y -q -c conda-forge openmm=8.2.0 python=\"${PYTHON_VERSION}\" pdbfixer 2>&1 1>/dev/null\n",
+ " touch AMBER_READY\n",
+ "fi"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hUYApPElB30u",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Run Prediction\n",
+ "\n",
+ "import sys\n",
+ "\n",
+ "from colabfold.batch import get_queries, run\n",
+ "from colabfold.download import default_data_dir\n",
+ "from colabfold.utils import setup_logging\n",
+ "from pathlib import Path\n",
+ "\n",
+ "# For some reason we need that to get pdbfixer to import\n",
+ "if use_amber and f\"/usr/local/lib/python{python_version}/site-packages/\" not in sys.path:\n",
+ " sys.path.insert(0, f\"/usr/local/lib/python{python_version}/site-packages/\")\n",
+ "\n",
+ "setup_logging(Path(result_dir).joinpath(\"log.txt\"))\n",
+ "\n",
+ "queries, is_complex = get_queries(input_dir)\n",
+ "run(\n",
+ " queries=queries,\n",
+ " result_dir=result_dir,\n",
+ " use_templates=use_templates,\n",
+ " num_relax=num_relax,\n",
+ " relax_max_iterations=relax_max_iterations,\n",
+ " msa_mode=msa_mode,\n",
+ " model_type=\"auto\",\n",
+ " num_models=num_models,\n",
+ " num_recycles=num_recycles,\n",
+ " model_order=[1, 2, 3, 4, 5],\n",
+ " is_complex=is_complex,\n",
+ " data_dir=default_data_dir,\n",
+ " keep_existing_results=do_not_overwrite_results,\n",
+ " rank_by=\"auto\",\n",
+ " pair_mode=\"unpaired+paired\",\n",
+ " stop_at_score=stop_at_score,\n",
+ " zip_results=zip_results,\n",
+ " user_agent=\"colabfold/google-colab-batch\",\n",
+ ")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UGUBLzB3C6WN"
+ },
+ "source": [
+ "# Instructions \n",
+ "**Quick start**\n",
+ "1. Upload your single fasta files to a folder in your Google Drive\n",
+ "2. Define path to the fold containing the fasta files (`input_dir`) define an outdir (`output_dir`)\n",
+ "3. Press \"Runtime\" -> \"Run all\".\n",
+ "\n",
+ "**Result zip file contents**\n",
+ "\n",
+ "At the end of the job a all results `jobname.result.zip` will be uploaded to your (`output_dir`) Google Drive. Each zip contains one protein.\n",
+ "\n",
+ "1. PDB formatted structures sorted by avg. pIDDT. (unrelaxed and relaxed if `use_amber` is enabled).\n",
+ "2. Plots of the model quality.\n",
+ "3. Plots of the MSA coverage.\n",
+ "4. Parameter log file.\n",
+ "5. A3M formatted input MSA.\n",
+ "6. BibTeX file with citations for all used tools and databases.\n",
+ "\n",
+ "\n",
+ "**Troubleshooting**\n",
+ "* Check that the runtime type is set to GPU at \"Runtime\" -> \"Change runtime type\".\n",
+ "* Try to restart the session \"Runtime\" -> \"Factory reset runtime\".\n",
+ "* Check your input sequence.\n",
+ "\n",
+ "**Known issues**\n",
+ "* Google Colab assigns different types of GPUs with varying amount of memory. Some might not have enough memory to predict the structure for a long sequence.\n",
+ "* Google Colab assigns different types of GPUs with varying amount of memory. Some might not have enough memory to predict the structure for a long sequence.\n",
+ "* Your browser can block the pop-up for downloading the result file. You can choose the `save_to_google_drive` option to upload to Google Drive instead or manually download the result file: Click on the little folder icon to the left, navigate to file: `jobname.result.zip`, right-click and select \\\"Download\\\" (see [screenshot](https://pbs.twimg.com/media/E6wRW2lWUAEOuoe?format=jpg&name=small)).\n",
+ "\n",
+ "**Limitations**\n",
+ "* Computing resources: Our MMseqs2 API can handle ~20-50k requests per day.\n",
+ "* MSAs: MMseqs2 is very precise and sensitive but might find less hits compared to HHblits/HMMer searched against BFD or Mgnify.\n",
+ "* We recommend to additionally use the full [AlphaFold2 pipeline](https://github.com/deepmind/alphafold).\n",
+ "\n",
+ "**Description of the plots**\n",
+ "* **Number of sequences per position** - We want to see at least 30 sequences per position, for best performance, ideally 100 sequences.\n",
+ "* **Predicted lDDT per position** - model confidence (out of 100) at each position. The higher the better.\n",
+ "* **Predicted Alignment Error** - For homooligomers, this could be a useful metric to assess how confident the model is about the interface. The lower the better.\n",
+ "\n",
+ "**Bugs**\n",
+ "- If you encounter any bugs, please report the issue to https://github.com/sokrypton/ColabFold/issues\n",
+ "\n",
+ "**License**\n",
+ "\n",
+ "The source code of ColabFold is licensed under [MIT](https://raw.githubusercontent.com/sokrypton/ColabFold/main/LICENSE). Additionally, this notebook uses AlphaFold2 source code and its parameters licensed under [Apache 2.0](https://raw.githubusercontent.com/deepmind/alphafold/main/LICENSE) and [CC BY 4.0](https://creativecommons.org/licenses/by-sa/4.0/) respectively. Read more about the AlphaFold license [here](https://github.com/deepmind/alphafold).\n",
+ "\n",
+ "**Acknowledgments**\n",
+ "- We thank the AlphaFold team for developing an excellent model and open sourcing the software.\n",
+ "\n",
+ "- Do-Yoon Kim for creating the ColabFold logo.\n",
+ "\n",
+ "- A colab by Sergey Ovchinnikov ([@sokrypton](https://twitter.com/sokrypton)), Milot Mirdita ([@milot_mirdita](https://twitter.com/milot_mirdita)) and Martin Steinegger ([@thesteinegger](https://twitter.com/thesteinegger)).\n"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/AlphaFold2_advanced.ipynb b/data/beta/AlphaFold2_advanced.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6fd7ff32b5810d4e129a80bc3f66cb23eb786b69
--- /dev/null
+++ b/data/beta/AlphaFold2_advanced.ipynb
@@ -0,0 +1,745 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "AlphaFold2_advanced.ipynb",
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pc5-mbsX9PZC"
+ },
+ "source": [
+ "# AlphaFold2_advanced\n",
+ "\n",
+ "This notebook modifies deepmind's [original notebook](https://colab.research.google.com/github/deepmind/alphafold/blob/main/notebooks/AlphaFold.ipynb) (**before AlphaFold-Multimer existed**) to add experimental support for modeling complexes (both homo and hetero-oligomers), option to run MMseqs2 instead of Jackhmmer for MSA generation and advanced functionality.\n",
+ "\n",
+ "See [ColabFold](https://github.com/sokrypton/ColabFold/) for other related notebooks\n",
+ "\n",
+ "[Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold: Making protein folding accessible to all.\n",
+ "*Nature Methods*, 2022](https://www.nature.com/articles/s41592-022-01488-1) \n",
+ "\n",
+ "**Limitations**\n",
+ "- This notebook does **NOT** use Templates.\n",
+ "- This notebook does **NOT** use AlphaFold-Multimer for complex (protein-protein) modeling.\n",
+ "- For a typical Google-Colab session, with a `16G-GPU`, the max total length is **1400 residues**. Sometimes a `12G-GPU` is assigned, in which the max length is ~1000 residues.\n",
+ "- Can I use the models for **Molecular Replacement**? Yes, but be CAREFUL, the bfactor column is populated with pLDDT confidence values (higher = better). Phenix.phaser expects a \"real\" bfactor, where (lower = better). See [post](https://twitter.com/cheshireminima/status/1423929241675120643) from Claudia Millán on how to process models."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "woIxeCPygt7K",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Install software\n",
+ "#@markdown Please execute this cell by pressing the _Play_ button \n",
+ "#@markdown on the left.\n",
+ "\n",
+ "# setup device\n",
+ "import warnings\n",
+ "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+ "\n",
+ "import os\n",
+ "import sys\n",
+ "import tensorflow as tf\n",
+ "import jax\n",
+ "\n",
+ "try:\n",
+ " # check if TPU is available\n",
+ " import jax.tools.colab_tpu\n",
+ " jax.tools.colab_tpu.setup_tpu()\n",
+ " print('Running on TPU')\n",
+ " DEVICE = \"tpu\"\n",
+ "except:\n",
+ " if jax.local_devices()[0].platform == 'cpu':\n",
+ " print(\"WARNING: no GPU detected, will be using CPU\")\n",
+ " DEVICE = \"cpu\"\n",
+ " else:\n",
+ " print('Running on GPU')\n",
+ " DEVICE = \"gpu\"\n",
+ " # disable GPU on tensorflow\n",
+ " tf.config.set_visible_devices([], 'GPU')\n",
+ "\n",
+ "from IPython.utils import io\n",
+ "import subprocess\n",
+ "import tqdm.notebook\n",
+ "\n",
+ "from sys import version_info \n",
+ "python_version = f\"{version_info.major}.{version_info.minor}\"\n",
+ "\n",
+ "install_jackhmmer = True\n",
+ "GIT_REPO = 'https://github.com/deepmind/alphafold'\n",
+ "SOURCE_URL = 'https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar'\n",
+ "PARAMS_DIR = './alphafold/data/params'\n",
+ "PARAMS_PATH = os.path.join(PARAMS_DIR, os.path.basename(SOURCE_URL))\n",
+ "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
+ "TMP_DIR = \"tmp\"\n",
+ "os.makedirs(TMP_DIR, exist_ok=True)\n",
+ "\n",
+ "# if not already installed\n",
+ "total = 55\n",
+ "with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " if not os.path.isdir(\"alphafold\"):\n",
+ " # download alphafold code\n",
+ " os.system(f\"git clone {GIT_REPO} alphafold; cd alphafold; git checkout 1d43aaff941c84dc56311076b58795797e49107b\")\n",
+ " os.system(f\"git clone https://github.com/sokrypton/ColabFold.git\")\n",
+ "\n",
+ " # apply patches\n",
+ " os.system(f\"patch -u alphafold/alphafold/model/model.py -i ColabFold/beta/model.patch\")\n",
+ " os.system(f\"patch -u alphafold/alphafold/model/mapping.py -i ColabFold/beta/mapping.patch\")\n",
+ " os.system(f\"patch -u alphafold/alphafold/model/modules.py -i ColabFold/beta/modules.patch\")\n",
+ " os.system(f\"patch -u alphafold/alphafold/model/folding.py -i ColabFold/beta/folding.patch\")\n",
+ " os.system(f\"patch -u alphafold/alphafold/model/config.py -i ColabFold/beta/config.patch\")\n",
+ " # apply multi-chain patch from Lim Heo @huhlim\n",
+ " os.system(f\"patch -u alphafold/alphafold/common/protein.py -i ColabFold/beta/protein.patch\")\n",
+ " pbar.update(4)\n",
+ "\n",
+ " os.system(f\"pip install biopython dm-haiku==0.0.9 ml-collections py3Dmol\")\n",
+ " pbar.update(6)\n",
+ "\n",
+ " # download model params (speedup from kaczmarj)\n",
+ " os.system(f\"mkdir --parents {PARAMS_DIR}\")\n",
+ " os.system(f\"curl -fsSL {SOURCE_URL} | tar x -C {PARAMS_DIR}\")\n",
+ " pbar.update(14+27)\n",
+ "\n",
+ " # install hhsuite\n",
+ " os.system(f\"curl -fsSL https://github.com/soedinglab/hh-suite/releases/download/v3.3.0/hhsuite-3.3.0-SSE2-Linux.tar.gz | tar xz -C {TMP_DIR}/\")\n",
+ "\n",
+ " # install jackhmmer\n",
+ " if install_jackhmmer:\n",
+ " os.system(f\"sudo apt install --quiet --yes hmmer\")\n",
+ " pbar.update(3)\n",
+ "\n",
+ " # create a ramdisk to store a database chunk to make Jackhmmer run fast.\n",
+ " os.system(f\"sudo mkdir -m 777 --parents /tmp/ramdisk\")\n",
+ " os.system(f\"sudo mount -t tmpfs -o size=9G ramdisk /tmp/ramdisk\")\n",
+ " pbar.update(1)\n",
+ "\n",
+ " else:\n",
+ " pbar.update(4)\n",
+ "\n",
+ " else:\n",
+ " pbar.update(55)\n",
+ "\n",
+ "########################################################################################\n",
+ "# --- Python imports ---\n",
+ "if 'alphafold' not in sys.path:\n",
+ " sys.path.append('alphafold')\n",
+ "if 'ColabFold/beta' not in sys.path:\n",
+ " sys.path.append('ColabFold/beta')\n",
+ "\n",
+ "if f\"{TMP_DIR}/bin\" not in os.environ['PATH']:\n",
+ " os.environ['PATH'] += f\":{TMP_DIR}/bin:{TMP_DIR}/scripts\"\n",
+ "\n",
+ "import colabfold as cf\n",
+ "import colabfold_alphafold as cf_af\n",
+ "\n",
+ "import json\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "try:\n",
+ " from google.colab import files\n",
+ " IN_COLAB = True\n",
+ "except:\n",
+ " IN_COLAB = False"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "rowN0bVYLe9n",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Enter the amino acid sequence to fold ⬇️\n",
+ "import re\n",
+ "\n",
+ "# define sequence\n",
+ "sequence = 'PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK' #@param {type:\"string\"}\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "homooligomer = \"1\" #@param {type:\"string\"}\n",
+ "\n",
+ "#@markdown - `sequence` Specify protein sequence to be modelled.\n",
+ "#@markdown - Use `/` to specify intra-protein chainbreaks (for trimming regions within protein).\n",
+ "#@markdown - Use `:` to specify inter-protein chainbreaks (for modeling protein-protein hetero-complexes).\n",
+ "#@markdown - For example, sequence `AC/DE:FGH` will be modelled as polypeptides: `AC`, `DE` and `FGH`. A seperate MSA will be generates for `ACDE` and `FGH`.\n",
+ "#@markdown If `pair_msa` is enabled, `ACDE`'s MSA will be paired with `FGH`'s MSA.\n",
+ "#@markdown - `homooligomer` Define number of copies in a homo-oligomeric assembly.\n",
+ "#@markdown - Use `:` to specify different homooligomeric state (copy numer) for each component of the complex. \n",
+ "#@markdown - For example, **sequence:**`ABC:DEF`, **homooligomer:** `2:1`, the first protein `ABC` will be modeled as a homodimer (2 copies) and second `DEF` a monomer (1 copy).\n",
+ "\n",
+ "I = cf_af.prep_inputs(sequence, jobname, homooligomer, clean=IN_COLAB)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ITcPnLkLuDDE",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Search against genetic databases\n",
+ "#@markdown Once this cell has been executed, you will see\n",
+ "#@markdown statistics about the multiple sequence alignment \n",
+ "#@markdown (MSA) that will be used by AlphaFold. In particular, \n",
+ "#@markdown you’ll see how well each residue is covered by similar \n",
+ "#@markdown sequences in the MSA.\n",
+ "#@markdown (Note that the search against databases and the actual prediction can take some time, from minutes to hours, depending on the length of the protein and what type of GPU you are allocated by Colab.)\n",
+ "\n",
+ "#@markdown ---\n",
+ "msa_method = \"mmseqs2\" #@param [\"mmseqs2\",\"jackhmmer\",\"single_sequence\",\"precomputed\"]\n",
+ "#@markdown - `mmseqs2` - FAST method from [ColabFold](https://github.com/sokrypton/ColabFold)\n",
+ "#@markdown - `jackhmmer` - default method from Deepmind (SLOW, but may find more/less sequences).\n",
+ "#@markdown - `single_sequence` - use single sequence input\n",
+ "#@markdown - `precomputed` If you have previously run this notebook and saved the results,\n",
+ "#@markdown you can skip this step by uploading \n",
+ "#@markdown the previously generated `prediction_?????/msa.pickle`\n",
+ "\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown **custom msa options**\n",
+ "add_custom_msa = False #@param {type:\"boolean\"}\n",
+ "msa_format = \"fas\" #@param [\"fas\",\"a2m\",\"a3m\",\"sto\",\"psi\",\"clu\"]\n",
+ "#@markdown - `add_custom_msa` - If enabled, you'll get an option to upload your custom MSA in the specified `msa_format`. Note: Your MSA will be supplemented with those from 'mmseqs2' or 'jackhmmer', unless `msa_method` is set to 'single_sequence'.\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown **pair msa options**\n",
+ "\n",
+ "#@markdown Experimental option for protein complexes. Pairing currently only supported for proteins in same operon (prokaryotic genomes).\n",
+ "pair_mode = \"unpaired\" #@param [\"unpaired\",\"unpaired+paired\",\"paired\"] {type:\"string\"}\n",
+ "#@markdown - `unpaired` - generate seperate MSA for each protein.\n",
+ "#@markdown - `unpaired+paired` - attempt to pair sequences from the same operon within the genome. \n",
+ "#@markdown - `paired` - only use sequences that were sucessfully paired.\n",
+ "\n",
+ "#@markdown Options to prefilter each MSA before pairing. (It might help if there are any paralogs in the complex.)\n",
+ "pair_cov = 50 #@param [0,25,50,75,90] {type:\"raw\"}\n",
+ "pair_qid = 20 #@param [0,15,20,30,40,50] {type:\"raw\"}\n",
+ "#@markdown - `pair_cov` prefilter each MSA to minimum coverage with query (%) before pairing.\n",
+ "#@markdown - `pair_qid` prefilter each MSA to minimum sequence identity with query (%) before pairing.\n",
+ "\n",
+ "# --- Search against genetic databases ---\n",
+ "\n",
+ "I = cf_af.prep_msa(I, msa_method, add_custom_msa, msa_format,\n",
+ " pair_mode, pair_cov, pair_qid, TMP_DIR=TMP_DIR)\n",
+ "mod_I = I\n",
+ "\n",
+ "if len(I[\"msas\"][0]) > 1:\n",
+ " plt = cf.plot_msas(I[\"msas\"], I[\"ori_sequence\"])\n",
+ " plt.savefig(os.path.join(I[\"output_dir\"],\"msa_coverage.png\"), bbox_inches = 'tight', dpi=200)\n",
+ " plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "sYIjwa1VXeeW",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Filter options (optional)\n",
+ "trim = \"\" #@param {type:\"string\"}\n",
+ "trim_inverse = False #@param {type:\"boolean\"}\n",
+ "#@markdown - Use `trim` to specify regions to trim. For example: `trim:5-9,20` will remove positions 5,6,7,8,9 and 20. \n",
+ "#@markdown - For complexes, you can use `trim:A1-A3,B5-B7` to remove positions 1,2,3 in 1st protein and positions 5,6,7 in 2nd protein.\n",
+ "#@markdown - Note: This function is 1-indexed, meaning the first position is 1, not 0.\n",
+ "#@markdown - To specify regions to keep instead of trim, enable `trim_inverse`\n",
+ "cov = 0 #@param [0,25,50,75,90,95] {type:\"raw\"}\n",
+ "qid = 0 #@param [0,15,20,25,30,40,50] {type:\"raw\"}\n",
+ "#@markdown - `cov` minimum coverage with query (%)\n",
+ "#@markdown - `qid` minimum sequence identity with query (%)\n",
+ "\n",
+ "mod_I = cf_af.prep_filter(I, trim, trim_inverse, cov, qid)\n",
+ "\n",
+ "if I[\"msas\"] != mod_I[\"msas\"]:\n",
+ " plt.figure(figsize=(16,5),dpi=100)\n",
+ " plt.subplot(1,2,1)\n",
+ " plt.title(\"Sequence coverage (Before)\")\n",
+ " cf.plot_msas(I[\"msas\"], I[\"ori_sequence\"], return_plt=False)\n",
+ " plt.subplot(1,2,2)\n",
+ " plt.title(\"Sequence coverage (After)\")\n",
+ " cf.plot_msas(mod_I[\"msas\"], mod_I[\"ori_sequence\"], return_plt=False)\n",
+ " plt.savefig(os.path.join(I[\"output_dir\"],\"msa_coverage.filtered.png\"), bbox_inches = 'tight', dpi=200)\n",
+ " plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "bQe3KeyTcv0n",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Run alphafold\n",
+ "num_relax = \"None\"\n",
+ "rank_by = \"pLDDT\" #@param [\"pLDDT\",\"pTMscore\"]\n",
+ "use_turbo = True #@param {type:\"boolean\"}\n",
+ "max_msa = \"512:1024\" #@param [\"512:1024\", \"256:512\", \"128:256\", \"64:128\", \"32:64\"]\n",
+ "max_msa_clusters, max_extra_msa = [int(x) for x in max_msa.split(\":\")]\n",
+ "\n",
+ "#@markdown - `rank_by` specify metric to use for ranking models (For protein-protein complexes, we recommend pTMscore)\n",
+ "#@markdown - `use_turbo` introduces a few modifications (compile once, swap params, adjust max_msa) to speedup and reduce memory requirements. Disable for default behavior.\n",
+ "#@markdown - `max_msa` defines: `max_msa_clusters:max_extra_msa` number of sequences to use. When adjusting after GPU crash, be sure to `Runtime` → `Restart runtime`. (Lowering will reduce GPU requirements, but may result in poor model quality. This option ignored if `use_turbo` is disabled)\n",
+ "show_images = True #@param {type:\"boolean\"}\n",
+ "#@markdown - `show_images` To make things more exciting we show images of the predicted structures as they are being generated. (WARNING: the order of images displayed does not reflect any ranking).\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown **sampling options**\n",
+ "\n",
+ "#@markdown There are two stochastic parts of the pipeline. Within the feature generation (choice of cluster centers) and within the model (dropout). \n",
+ "#@markdown To get structure diversity, you can iterate through a fixed number of random_seeds (using `num_samples`) and/or enable dropout (using `is_training`).\n",
+ "\n",
+ "num_models = 5 #@param [1,2,3,4,5] {type:\"raw\"}\n",
+ "use_ptm = True #@param {type:\"boolean\"}\n",
+ "num_ensemble = 1 #@param [1,2,4,8] {type:\"raw\"}\n",
+ "max_recycles = 3 #@param [0,1,3,6,12,24,48] {type:\"raw\"}\n",
+ "is_training = False #@param {type:\"boolean\"}\n",
+ "num_samples = 1 #@param [1,2,4,8,16,32] {type:\"raw\"}\n",
+ "#@markdown - `num_models` specify how many model params to try. (5 recommended)\n",
+ "#@markdown - `use_ptm` uses Deepmind's `ptm` finetuned model parameters to get PAE per structure. Disable to use the original model params. (Disabling may give alternative structures.)\n",
+ "#@markdown - `num_ensemble` the trunk of the network is run multiple times with different random choices for the MSA cluster centers. (`1`=`default`, `8`=`casp14 setting`)\n",
+ "#@markdown - `max_recycles` controls the maximum number of times the structure is fed back into the neural network for refinement. (3 recommended)\n",
+ "#@markdown - `is_training` enables the stochastic part of the model (dropout), when coupled with `num_samples` can be used to \"sample\" a diverse set of structures.\n",
+ "#@markdown - `num_samples` number of random_seeds to try.\n",
+ "subsample_msa = True #@param {type:\"boolean\"}\n",
+ "#@markdown - `subsample_msa` subsample large MSA to `3E7/length` sequences to avoid crashing the preprocessing protocol. (This option ignored if `use_turbo` is disabled.)\n",
+ "\n",
+ "if not use_ptm and rank_by == \"pTMscore\":\n",
+ " print(\"WARNING: models will be ranked by pLDDT, 'use_ptm' is needed to compute pTMscore\")\n",
+ " rank_by = \"pLDDT\"\n",
+ "\n",
+ "# prep input features\n",
+ "feature_dict = cf_af.prep_feats(mod_I, clean=IN_COLAB)\n",
+ "Ls_plot = feature_dict[\"Ls\"]\n",
+ "\n",
+ "# prep model options\n",
+ "opt = {\"N\":len(feature_dict[\"msa\"]),\n",
+ " \"L\":len(feature_dict[\"residue_index\"]),\n",
+ " \"use_ptm\":use_ptm,\n",
+ " \"use_turbo\":use_turbo,\n",
+ " \"max_recycles\":max_recycles,\n",
+ " \"tol\":0.0,\n",
+ " \"num_ensemble\":num_ensemble,\n",
+ " \"max_msa_clusters\":max_msa_clusters,\n",
+ " \"max_extra_msa\":max_extra_msa,\n",
+ " \"is_training\":is_training}\n",
+ "\n",
+ "if use_turbo:\n",
+ " if \"runner\" in dir():\n",
+ " # only recompile if options changed\n",
+ " runner = cf_af.prep_model_runner(opt, old_runner=runner)\n",
+ " else:\n",
+ " runner = cf_af.prep_model_runner(opt)\n",
+ "else:\n",
+ " runner = None\n",
+ "\n",
+ "###########################\n",
+ "# run alphafold\n",
+ "###########################\n",
+ "outs, model_rank = cf_af.run_alphafold(feature_dict, opt, runner, num_models, num_samples, subsample_msa,\n",
+ " rank_by=rank_by, show_images=show_images)\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "PnMog4kHUztt",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Refine structures with Amber-Relax (optional)\n",
+ "#@markdown If side-chain bond geometry is important to you, enable Amber-Relax by specifying how many top ranked structures you want relaxed. By default, we disable Amber-Relax since it barely moves the main-chain (backbone) structure and can overall double the runtime.\n",
+ "num_relax = \"None\" #@param [\"None\", \"Top1\", \"Top5\", \"All\"] {type:\"string\"}\n",
+ "if num_relax == \"None\":\n",
+ " num_relax = 0\n",
+ "elif num_relax == \"Top1\":\n",
+ " num_relax = 1\n",
+ "elif num_relax == \"Top5\":\n",
+ " num_relax = 5\n",
+ "else:\n",
+ " num_relax = num_models * num_samples\n",
+ "\n",
+ "#@markdown - `num_relax` specify how many of the top ranked structures to relax\n",
+ "if num_relax > 0 and not os.path.isfile(\"stereo_chemical_props.txt\"):\n",
+ " try:\n",
+ " total = 45\n",
+ " with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " pbar.set_description(f'INSTALL AMBER')\n",
+ " with io.capture_output() as captured:\n",
+ " # Install OpenMM and pdbfixer.\n",
+ " %shell rm -rf /opt/conda\n",
+ " %shell wget -q -P /tmp \\\n",
+ " https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \\\n",
+ " && bash /tmp/Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda \\\n",
+ " && rm /tmp/Miniconda3-latest-Linux-x86_64.sh\n",
+ " pbar.update(4)\n",
+ "\n",
+ " PATH=%env PATH\n",
+ " %env PATH=/opt/conda/bin:{PATH}\n",
+ " %shell conda install -qy conda==4.13.0 \\\n",
+ " && conda install -qy -c conda-forge \\\n",
+ " python={python_version} \\\n",
+ " openmm=7.5.1 \\\n",
+ " pdbfixer\n",
+ " pbar.update(40)\n",
+ "\n",
+ " %shell wget -q -P /content \\\n",
+ " https://git.scicore.unibas.ch/schwede/openstructure/-/raw/7102c63615b64735c4941278d92b554ec94415f8/modules/mol/alg/src/stereo_chemical_props.txt\n",
+ " pbar.update(1)\n",
+ " %shell mkdir -p /content/alphafold/common\n",
+ " %shell cp -f /content/stereo_chemical_props.txt /content/alphafold/common\n",
+ "\n",
+ " # Apply OpenMM patch.\n",
+ " %shell pushd /opt/conda/lib/python{python_version}/site-packages/ && \\\n",
+ " patch -p0 < /content/alphafold/docker/openmm.patch && \\\n",
+ " popd\n",
+ "\n",
+ " except subprocess.CalledProcessError:\n",
+ " print(captured)\n",
+ " raise\n",
+ "\n",
+ "if num_relax > 0:\n",
+ " if \"relax\" not in dir():\n",
+ " # add conda environment to path\n",
+ " sys.path.append(f\"/opt/conda/lib/python{python_version}/site-packages\")\n",
+ " if 'LC_ALL' in os.environ:\n",
+ " del os.environ['LC_ALL']\n",
+ " \n",
+ " # import libraries\n",
+ " from alphafold.relax import relax\n",
+ " from alphafold.relax import utils\n",
+ "\n",
+ " with tqdm.notebook.tqdm(total=num_relax, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " pbar.set_description(f'AMBER relaxation')\n",
+ " for n,key in enumerate(model_rank):\n",
+ " if n < num_relax:\n",
+ " prefix = f\"rank_{n+1}_{key}\" \n",
+ " pred_output_path = os.path.join(I[\"output_dir\"],f'{prefix}_relaxed.pdb')\n",
+ " if not os.path.isfile(pred_output_path):\n",
+ " amber_relaxer = relax.AmberRelaxation(\n",
+ " max_iterations=0,\n",
+ " tolerance=2.39,\n",
+ " stiffness=10.0,\n",
+ " exclude_residues=[],\n",
+ " max_outer_iterations=20)\n",
+ " relaxed_pdb_lines, _, _ = amber_relaxer.process(prot=outs[key][\"unrelaxed_protein\"]) \n",
+ " with open(pred_output_path, 'w') as f:\n",
+ " f.write(relaxed_pdb_lines)\n",
+ " pbar.update(n=1)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KAZj6CBZTkJM",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure (optional) {run: \"auto\"}\n",
+ "rank_num = 1 #@param [\"1\", \"2\", \"3\", \"4\", \"5\"] {type:\"raw\"}\n",
+ "color = \"lDDT\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "key = model_rank[rank_num-1]\n",
+ "prefix = f\"rank_{rank_num}_{key}\" \n",
+ "pred_output_path = os.path.join(I[\"output_dir\"],f'{prefix}_relaxed.pdb') \n",
+ "if not os.path.isfile(pred_output_path):\n",
+ " pred_output_path = os.path.join(I[\"output_dir\"],f'{prefix}_unrelaxed.pdb') \n",
+ "\n",
+ "cf.show_pdb(pred_output_path, show_sidechains, show_mainchains, color, Ls=Ls_plot).show()\n",
+ "if color == \"lDDT\": cf.plot_plddt_legend().show() \n",
+ "if use_ptm:\n",
+ " cf.plot_confidence(outs[key][\"plddt\"], outs[key][\"pae\"], Ls=Ls_plot).show()\n",
+ "else:\n",
+ " cf.plot_confidence(outs[key][\"plddt\"], Ls=Ls_plot).show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "XzK2Wve12GCk",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Extra outputs (optional)\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "save_to_txt = True #@param {type:\"boolean\"}\n",
+ "save_pae_json = True #@param {type:\"boolean\"}\n",
+ "#@markdown - save data used to generate contact and distogram plots below to text file (pae values can be found in json file if `use_ptm` is enabled)\n",
+ "\n",
+ "if use_ptm:\n",
+ " print(\"predicted alignment error\")\n",
+ " cf.plot_paes([outs[k][\"pae\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ " plt.savefig(os.path.join(I[\"output_dir\"],f'predicted_alignment_error.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ " plt.show()\n",
+ "\n",
+ "print(\"predicted contacts\")\n",
+ "cf.plot_adjs([outs[k][\"adj\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ "plt.savefig(os.path.join(I[\"output_dir\"],f'predicted_contacts.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ "plt.show()\n",
+ "\n",
+ "print(\"predicted distogram\")\n",
+ "cf.plot_dists([outs[k][\"dists\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ "plt.savefig(os.path.join(I[\"output_dir\"],f'predicted_distogram.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ "plt.show()\n",
+ "\n",
+ "print(\"predicted LDDT\")\n",
+ "cf.plot_plddts([outs[k][\"plddt\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ "plt.savefig(os.path.join(I[\"output_dir\"],f'predicted_LDDT.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ "plt.show()\n",
+ "\n",
+ "def do_save_to_txt(filename, adj, dists, sequence):\n",
+ " adj = np.asarray(adj)\n",
+ " dists = np.asarray(dists)\n",
+ " L = len(adj)\n",
+ " with open(filename,\"w\") as out:\n",
+ " out.write(\"i\\tj\\taa_i\\taa_j\\tp(cbcb<8)\\tmaxdistbin\\n\")\n",
+ " for i in range(L):\n",
+ " for j in range(i+1,L):\n",
+ " if dists[i][j] < 21.68 or adj[i][j] >= 0.001:\n",
+ " line = f\"{i}\\t{j}\\t{sequence[i]}\\t{sequence[j]}\\t{adj[i][j]:.3f}\"\n",
+ " line += f\"\\t>{dists[i][j]:.2f}\" if dists[i][j] == 21.6875 else f\"\\t{dists[i][j]:.2f}\"\n",
+ " out.write(f\"{line}\\n\")\n",
+ "\n",
+ "for n,key in enumerate(model_rank):\n",
+ " if save_to_txt:\n",
+ " txt_filename = os.path.join(I[\"output_dir\"],f'rank_{n+1}_{key}.raw.txt')\n",
+ " do_save_to_txt(txt_filename,\n",
+ " outs[key][\"adj\"],\n",
+ " outs[key][\"dists\"],\n",
+ " mod_I[\"full_sequence\"])\n",
+ "\n",
+ " if use_ptm and save_pae_json:\n",
+ " pae = outs[key][\"pae\"]\n",
+ " max_pae = pae.max()\n",
+ " # Save pLDDT and predicted aligned error (if it exists)\n",
+ " pae_output_path = os.path.join(I[\"output_dir\"],f'rank_{n+1}_{key}_pae.json')\n",
+ " # Save predicted aligned error in the same format as the AF EMBL DB\n",
+ " rounded_errors = np.round(np.asarray(pae), decimals=1)\n",
+ " indices = np.indices((len(rounded_errors), len(rounded_errors))) + 1\n",
+ " indices_1 = indices[0].flatten().tolist()\n",
+ " indices_2 = indices[1].flatten().tolist()\n",
+ " pae_data = json.dumps([{\n",
+ " 'residue1': indices_1,\n",
+ " 'residue2': indices_2,\n",
+ " 'distance': rounded_errors.flatten().tolist(),\n",
+ " 'max_predicted_aligned_error': max_pae.item()\n",
+ " }],\n",
+ " indent=None,\n",
+ " separators=(',', ':'))\n",
+ " with open(pae_output_path, 'w') as f:\n",
+ " f.write(pae_data)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "cellView": "form",
+ "id": "xkCcitL6qdNS"
+ },
+ "source": [
+ "#@title Animate outputs (optional)\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "use_pca = True #@param {type:\"boolean\"}\n",
+ "color_by_plddt = False #@param {type:\"boolean\"}\n",
+ "#@markdown - `use_pca` - use the first principle component to determine order of animation frames\n",
+ "\n",
+ "\n",
+ "import matplotlib\n",
+ "from matplotlib import animation\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.decomposition import PCA\n",
+ "\n",
+ "def mk_animation(positions, labels, plddt, ref=0, Ls=None, line_w=2.0, dpi=100,color_by_plddt=False):\n",
+ "\n",
+ " def ca_align_to_last(positions, ref):\n",
+ " def align(P, Q):\n",
+ " if Ls is None or len(Ls) == 1:\n",
+ " P_,Q_ = P,Q\n",
+ " else:\n",
+ " # align relative to first chain\n",
+ " P_,Q_ = P[:Ls[0]],Q[:Ls[0]]\n",
+ " p = P_ - P_.mean(0,keepdims=True)\n",
+ " q = Q_ - Q_.mean(0,keepdims=True)\n",
+ " return ((P - P_.mean(0,keepdims=True)) @ cf.kabsch(p,q)) + Q_.mean(0,keepdims=True)\n",
+ " \n",
+ " pos = positions[ref,:,1,:] - positions[ref,:,1,:].mean(0,keepdims=True)\n",
+ " best_2D_view = pos @ cf.kabsch(pos,pos,return_v=True)\n",
+ "\n",
+ " new_positions = []\n",
+ " for i in range(len(positions)):\n",
+ " new_positions.append(align(positions[i,:,1,:],best_2D_view))\n",
+ " return np.asarray(new_positions)\n",
+ "\n",
+ " # align to reference \n",
+ " pos = ca_align_to_last(positions, ref)\n",
+ "\n",
+ " fig, (ax1) = plt.subplots(1)\n",
+ " fig.set_figwidth(5)\n",
+ " fig.set_figheight(5)\n",
+ " fig.set_dpi(dpi)\n",
+ "\n",
+ " xy_min = pos[...,:2].min() - 1\n",
+ " xy_max = pos[...,:2].max() + 1\n",
+ "\n",
+ " for ax in [ax1]:\n",
+ " ax.set_xlim(xy_min, xy_max)\n",
+ " ax.set_ylim(xy_min, xy_max)\n",
+ " ax.axis(False)\n",
+ "\n",
+ " ims=[]\n",
+ " for l,pos_,plddt_ in zip(labels,pos,plddt):\n",
+ " if color_by_plddt:\n",
+ " img = cf.plot_pseudo_3D(pos_, c=plddt_, cmin=50, cmax=90, line_w=line_w, ax=ax1) \n",
+ " elif Ls is None or len(Ls) == 1:\n",
+ " img = cf.plot_pseudo_3D(pos_, ax=ax1, line_w=line_w)\n",
+ " else:\n",
+ " c = np.concatenate([[n]*L for n,L in enumerate(Ls)])\n",
+ " img = cf.plot_pseudo_3D(pos_, c=c, cmap=cf.pymol_cmap, cmin=0, cmax=39, line_w=line_w, ax=ax1)\n",
+ " ims.append([cf.add_text(f\"{l}\", ax1),img])\n",
+ " \n",
+ " ani = animation.ArtistAnimation(fig, ims, blit=True, interval=120)\n",
+ " plt.close()\n",
+ " return ani.to_html5_video()\n",
+ "\n",
+ "labels = np.array([k for k in outs])\n",
+ "pos = np.array([outs[k][\"unrelaxed_protein\"].atom_positions for k in labels])\n",
+ "plddt = np.asarray([outs[k][\"plddt\"] for k in outs.keys()])\n",
+ "if use_pca:\n",
+ " pos_ca = pos[:,:,1,:]\n",
+ " if Ls_plot is not None and len(Ls_plot) > 1:\n",
+ " pos_ca = pos_ca[:,:Ls_plot[0]]\n",
+ " i,j = np.triu_indices(pos_ca.shape[1],k=1)\n",
+ " pos_ca_dm = np.sqrt(np.square(pos_ca[:,None,:,:] - pos_ca[:,:,None]).sum(-1))[:,i,j]\n",
+ " pc = PCA(1).fit_transform(pos_ca_dm)[:,0].argsort()\n",
+ " pos = pos[pc]\n",
+ " labels = labels[pc]\n",
+ " plddt = plddt[pc]\n",
+ "\n",
+ "HTML(mk_animation(pos, labels, plddt, Ls=Ls_plot, dpi=dpi, color_by_plddt=color_by_plddt))"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Riekgf0KQv_3",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Download prediction\n",
+ "\n",
+ "#@markdown Once this cell has been executed, a zip-archive with \n",
+ "#@markdown the obtained prediction will be automatically downloaded \n",
+ "#@markdown to your computer.\n",
+ "\n",
+ "# add settings file\n",
+ "settings_path = os.path.join(I[\"output_dir\"],\"settings.txt\")\n",
+ "with open(settings_path, \"w\") as text_file:\n",
+ " text_file.write(f\"notebook=https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/beta/AlphaFold2_advanced_beta.ipynb\\n\")\n",
+ " text_file.write(f\"sequence={I['ori_sequence']}\\n\")\n",
+ " text_file.write(f\"msa_method={msa_method}\\n\")\n",
+ " if add_custom_msa:\n",
+ " text_file.write(f\"add_custom_msa={add_custom_msa} msa_format={msa_format}\\n\")\n",
+ " text_file.write(f\"homooligomer={I['homooligomer']}\\n\")\n",
+ "\n",
+ " text_file.write(f\"pair_mode={pair_mode}\\n\")\n",
+ " if pair_mode != \"unpaired\":\n",
+ " text_file.write(f\"pair_cov={pair_cov}\\n\")\n",
+ " text_file.write(f\"pair_qid={pair_qid}\\n\")\n",
+ " \n",
+ " if I[\"ori_sequence\"] != mod_I[\"ori_sequence\"]:\n",
+ " text_file.write(f\"mod_sequence={mod_I['ori_sequence']}\\n\")\n",
+ " text_file.write(f\"trim={trim}\\n\")\n",
+ " text_file.write(f\"trim_inverse={trim_inverse}\\n\")\n",
+ " \n",
+ " if \"cov\" in dir():\n",
+ " text_file.write(f\"cov={cov}\\n\")\n",
+ " text_file.write(f\"qid={qid}\\n\")\n",
+ " else:\n",
+ " text_file.write(f\"cov=0\\nqid=0\\n\")\n",
+ "\n",
+ " text_file.write(f\"max_msa={max_msa}\\n\")\n",
+ " text_file.write(f\"subsample_msa={subsample_msa}\\n\") \n",
+ " text_file.write(f\"num_relax={num_relax}\\n\")\n",
+ " text_file.write(f\"use_turbo={use_turbo}\\n\")\n",
+ " text_file.write(f\"use_ptm={use_ptm}\\n\")\n",
+ " text_file.write(f\"rank_by={rank_by}\\n\")\n",
+ " text_file.write(f\"num_models={num_models}\\n\")\n",
+ " text_file.write(f\"num_samples={num_samples}\\n\")\n",
+ " text_file.write(f\"num_ensemble={num_ensemble}\\n\")\n",
+ " text_file.write(f\"max_recycles={max_recycles}\\n\")\n",
+ " text_file.write(f\"is_training={is_training}\\n\")\n",
+ " text_file.write(f\"use_templates=False\\n\")\n",
+ " text_file.write(f\"-------------------------------------------------\\n\")\n",
+ "\n",
+ " for n,key in enumerate(model_rank):\n",
+ " line = f\"rank_{n+1}_{key} pLDDT:{outs[key]['pLDDT']:.2f}\" + f\" pTMscore:{outs[key]['pTMscore']:.4f}\" if use_ptm else \"\"\n",
+ " text_file.write(line+\"\\n\")\n",
+ "\n",
+ "# --- Download the predictions ---\n",
+ "os.system(f'zip -FSr {I[\"output_dir\"]}.zip {I[\"output_dir\"]}')\n",
+ "if IN_COLAB:\n",
+ " files.download(f'{I[\"output_dir\"]}.zip')\n",
+ "else:\n",
+ " print(\"this notebook appears to be running locally, to download click folder icon to the left, navigate to file, right click and download\")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# License\n",
+ "\n",
+ "The source code of ColabFold is licensed under [MIT](https://raw.githubusercontent.com/sokrypton/ColabFold/main/LICENSE). Read more about the AlphaFold license [here](https://github.com/deepmind/alphafold)."
+ ],
+ "metadata": {
+ "id": "0RoRCHFJZgmF"
+ }
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/AlphaFold2_advanced_beta.ipynb b/data/beta/AlphaFold2_advanced_beta.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e575b35996065a3b0b81e079d3650c9886b794a5
--- /dev/null
+++ b/data/beta/AlphaFold2_advanced_beta.ipynb
@@ -0,0 +1,43 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "AlphaFold2_advanced_beta.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pc5-mbsX9PZC"
+ },
+ "source": [
+ "# AlphaFold2_advanced_beta\n",
+ "\n",
+ "**WARNING** This is beta (or development) version of the advanced notebook. The latest edits were merged into: https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/beta/AlphaFold2_advanced.ipynb"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/AlphaFold2_advanced_old.ipynb b/data/beta/AlphaFold2_advanced_old.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..470c39285f19d7e413235b46ba6863642c5bc6ce
--- /dev/null
+++ b/data/beta/AlphaFold2_advanced_old.ipynb
@@ -0,0 +1,1127 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "AlphaFold2_advanced.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pc5-mbsX9PZC"
+ },
+ "source": [
+ "# AlphaFold2_advanced\n",
+ "\n",
+ "-----------------\n",
+ "- 21Aug2021: MMseqs2 API has finished upgrade, all should be ready to go! Report any errors.\n",
+ "\n",
+ "-----------------\n",
+ "\n",
+ "This notebook modifies deepmind's [original notebook](https://colab.research.google.com/github/deepmind/alphafold/blob/main/notebooks/AlphaFold.ipynb) to add experimental support for modeling complexes (both homo and hetero-oligomers), option to run MMseqs2 instead of Jackhmmer for MSA generation and advanced functionality.\n",
+ "\n",
+ "See [ColabFold](https://github.com/sokrypton/ColabFold/) for other related notebooks\n",
+ "\n",
+ "**Limitations**\n",
+ "- This notebook does NOT use Templates.\n",
+ "- For a typical Google-Colab session, with a `16G-GPU`, the max total length is **1400 residues**. Sometimes a `12G-GPU` is assigned, in which the max length is ~1000 residues.\n",
+ "- Can I use the models for **Molecular Replacement**? Yes, but be CAREFUL, the bfactor column is populated with pLDDT confidence values (higher = better). Phenix.phaser expects a \"real\" bfactor, where (lower = better). See [post](https://twitter.com/cheshireminima/status/1423929241675120643) from Claudia Millán on how to process models."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "woIxeCPygt7K",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Install software\n",
+ "#@markdown Please execute this cell by pressing the _Play_ button \n",
+ "#@markdown on the left.\n",
+ "\n",
+ "import os\n",
+ "import tensorflow as tf\n",
+ "tf.config.set_visible_devices([], 'GPU')\n",
+ "\n",
+ "import jax\n",
+ "if jax.local_devices()[0].platform == 'tpu':\n",
+ " raise RuntimeError('Colab TPU runtime not supported. Change it to GPU via Runtime -> Change Runtime Type -> Hardware accelerator -> GPU.')\n",
+ "elif jax.local_devices()[0].platform == 'cpu':\n",
+ " raise RuntimeError('Colab CPU runtime not supported. Change it to GPU via Runtime -> Change Runtime Type -> Hardware accelerator -> GPU.')\n",
+ "\n",
+ "from IPython.utils import io\n",
+ "import subprocess\n",
+ "import tqdm.notebook\n",
+ "\n",
+ "from sys import version_info \n",
+ "python_version = f\"{version_info.major}.{version_info.minor}\"\n",
+ "\n",
+ "GIT_REPO = 'https://github.com/deepmind/alphafold'\n",
+ "SOURCE_URL = 'https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar'\n",
+ "PARAMS_DIR = './alphafold/data/params'\n",
+ "PARAMS_PATH = os.path.join(PARAMS_DIR, os.path.basename(SOURCE_URL))\n",
+ "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
+ "\n",
+ "# if not already installed\n",
+ "try:\n",
+ " total = 55\n",
+ " with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " with io.capture_output() as captured:\n",
+ " if not os.path.isdir(\"alphafold\"):\n",
+ " %shell rm -rf alphafold\n",
+ " %shell git clone {GIT_REPO} alphafold\n",
+ " %shell (cd alphafold; git checkout 1d43aaff941c84dc56311076b58795797e49107b --quiet)\n",
+ "\n",
+ " # colabfold patches\n",
+ " %shell mkdir --parents tmp\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/pairmsa.py\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/protein.patch -P tmp/\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/config.patch -P tmp/\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/model.patch -P tmp/\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/modules.patch -P tmp/\n",
+ "\n",
+ " # install hhsuite\n",
+ " %shell curl -fsSL https://github.com/soedinglab/hh-suite/releases/download/v3.3.0/hhsuite-3.3.0-SSE2-Linux.tar.gz | tar xz -C tmp/\n",
+ "\n",
+ " # Apply multi-chain patch from Lim Heo @huhlim\n",
+ " %shell patch -u alphafold/alphafold/common/protein.py -i tmp/protein.patch\n",
+ " \n",
+ " # Apply patch to dynamically control number of recycles (idea from Ryan Kibler)\n",
+ " %shell patch -u alphafold/alphafold/model/model.py -i tmp/model.patch\n",
+ " %shell patch -u alphafold/alphafold/model/modules.py -i tmp/modules.patch\n",
+ " %shell patch -u alphafold/alphafold/model/config.py -i tmp/config.patch\n",
+ " pbar.update(4)\n",
+ "\n",
+ " %shell pip3 install biopython dm-haiku ml-collections py3Dmol\n",
+ " %shell pip3 install --no-dependencies ./alphafold\n",
+ " pbar.update(6)\n",
+ "\n",
+ " # speedup from kaczmarj\n",
+ " %shell mkdir --parents \"{PARAMS_DIR}\"\n",
+ " %shell curl -fsSL \"{SOURCE_URL}\" | tar x -C \"{PARAMS_DIR}\"\n",
+ " pbar.update(14+27)\n",
+ "\n",
+ " #######################################################################\n",
+ " %shell sudo apt install --quiet --yes hmmer\n",
+ " pbar.update(3)\n",
+ "\n",
+ " # Create a ramdisk to store a database chunk to make Jackhmmer run fast.\n",
+ " %shell sudo mkdir -m 777 --parents /tmp/ramdisk\n",
+ " %shell sudo mount -t tmpfs -o size=9G ramdisk /tmp/ramdisk\n",
+ " pbar.update(1)\n",
+ " else:\n",
+ " pbar.update(55)\n",
+ "\n",
+ "except subprocess.CalledProcessError:\n",
+ " print(captured)\n",
+ " raise\n",
+ "\n",
+ "########################################################################################\n",
+ "# --- Python imports ---\n",
+ "import colabfold as cf\n",
+ "import pairmsa\n",
+ "import sys\n",
+ "import pickle\n",
+ "\n",
+ "if \"/content/tmp/bin\" not in os.environ['PATH']:\n",
+ " os.environ['PATH'] += \":/content/tmp/bin:/content/tmp/scripts\"\n",
+ "\n",
+ "from urllib import request\n",
+ "from concurrent import futures\n",
+ "from google.colab import files\n",
+ "import json\n",
+ "from matplotlib import gridspec\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import py3Dmol\n",
+ "\n",
+ "from alphafold.model import model\n",
+ "from alphafold.model import config\n",
+ "from alphafold.model import data\n",
+ "\n",
+ "from alphafold.data import parsers\n",
+ "from alphafold.data import pipeline\n",
+ "from alphafold.data.tools import jackhmmer\n",
+ "\n",
+ "from alphafold.common import protein\n",
+ "\n",
+ "def run_jackhmmer(sequence, prefix):\n",
+ "\n",
+ " fasta_path = f\"{prefix}.fasta\"\n",
+ " with open(fasta_path, 'wt') as f:\n",
+ " f.write(f'>query\\n{sequence}')\n",
+ "\n",
+ " pickled_msa_path = f\"{prefix}.jackhmmer.pickle\"\n",
+ " if os.path.isfile(pickled_msa_path):\n",
+ " msas_dict = pickle.load(open(pickled_msa_path,\"rb\"))\n",
+ " msas, deletion_matrices, names = (msas_dict[k] for k in ['msas', 'deletion_matrices', 'names'])\n",
+ " full_msa = []\n",
+ " for msa in msas:\n",
+ " full_msa += msa\n",
+ " else:\n",
+ " # --- Find the closest source ---\n",
+ " test_url_pattern = 'https://storage.googleapis.com/alphafold-colab{:s}/latest/uniref90_2021_03.fasta.1'\n",
+ " ex = futures.ThreadPoolExecutor(3)\n",
+ " def fetch(source):\n",
+ " request.urlretrieve(test_url_pattern.format(source))\n",
+ " return source\n",
+ " fs = [ex.submit(fetch, source) for source in ['', '-europe', '-asia']]\n",
+ " source = None\n",
+ " for f in futures.as_completed(fs):\n",
+ " source = f.result()\n",
+ " ex.shutdown()\n",
+ " break\n",
+ "\n",
+ " jackhmmer_binary_path = '/usr/bin/jackhmmer'\n",
+ " dbs = []\n",
+ "\n",
+ " num_jackhmmer_chunks = {'uniref90': 59, 'smallbfd': 17, 'mgnify': 71}\n",
+ " total_jackhmmer_chunks = sum(num_jackhmmer_chunks.values())\n",
+ " with tqdm.notebook.tqdm(total=total_jackhmmer_chunks, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " def jackhmmer_chunk_callback(i):\n",
+ " pbar.update(n=1)\n",
+ "\n",
+ " pbar.set_description('Searching uniref90')\n",
+ " jackhmmer_uniref90_runner = jackhmmer.Jackhmmer(\n",
+ " binary_path=jackhmmer_binary_path,\n",
+ " database_path=f'https://storage.googleapis.com/alphafold-colab{source}/latest/uniref90_2021_03.fasta',\n",
+ " get_tblout=True,\n",
+ " num_streamed_chunks=num_jackhmmer_chunks['uniref90'],\n",
+ " streaming_callback=jackhmmer_chunk_callback,\n",
+ " z_value=135301051)\n",
+ " dbs.append(('uniref90', jackhmmer_uniref90_runner.query(fasta_path)))\n",
+ "\n",
+ " pbar.set_description('Searching smallbfd')\n",
+ " jackhmmer_smallbfd_runner = jackhmmer.Jackhmmer(\n",
+ " binary_path=jackhmmer_binary_path,\n",
+ " database_path=f'https://storage.googleapis.com/alphafold-colab{source}/latest/bfd-first_non_consensus_sequences.fasta',\n",
+ " get_tblout=True,\n",
+ " num_streamed_chunks=num_jackhmmer_chunks['smallbfd'],\n",
+ " streaming_callback=jackhmmer_chunk_callback,\n",
+ " z_value=65984053)\n",
+ " dbs.append(('smallbfd', jackhmmer_smallbfd_runner.query(fasta_path)))\n",
+ "\n",
+ " pbar.set_description('Searching mgnify')\n",
+ " jackhmmer_mgnify_runner = jackhmmer.Jackhmmer(\n",
+ " binary_path=jackhmmer_binary_path,\n",
+ " database_path=f'https://storage.googleapis.com/alphafold-colab{source}/latest/mgy_clusters_2019_05.fasta',\n",
+ " get_tblout=True,\n",
+ " num_streamed_chunks=num_jackhmmer_chunks['mgnify'],\n",
+ " streaming_callback=jackhmmer_chunk_callback,\n",
+ " z_value=304820129)\n",
+ " dbs.append(('mgnify', jackhmmer_mgnify_runner.query(fasta_path)))\n",
+ "\n",
+ " # --- Extract the MSAs and visualize ---\n",
+ " # Extract the MSAs from the Stockholm files.\n",
+ " # NB: deduplication happens later in pipeline.make_msa_features.\n",
+ "\n",
+ " mgnify_max_hits = 501\n",
+ " msas = []\n",
+ " deletion_matrices = []\n",
+ " names = []\n",
+ " for db_name, db_results in dbs:\n",
+ " unsorted_results = []\n",
+ " for i, result in enumerate(db_results):\n",
+ " msa, deletion_matrix, target_names = parsers.parse_stockholm(result['sto'])\n",
+ " e_values_dict = parsers.parse_e_values_from_tblout(result['tbl'])\n",
+ " e_values = [e_values_dict[t.split('/')[0]] for t in target_names]\n",
+ " zipped_results = zip(msa, deletion_matrix, target_names, e_values)\n",
+ " if i != 0:\n",
+ " # Only take query from the first chunk\n",
+ " zipped_results = [x for x in zipped_results if x[2] != 'query']\n",
+ " unsorted_results.extend(zipped_results)\n",
+ " sorted_by_evalue = sorted(unsorted_results, key=lambda x: x[3])\n",
+ " db_msas, db_deletion_matrices, db_names, _ = zip(*sorted_by_evalue)\n",
+ " if db_msas:\n",
+ " if db_name == 'mgnify':\n",
+ " db_msas = db_msas[:mgnify_max_hits]\n",
+ " db_deletion_matrices = db_deletion_matrices[:mgnify_max_hits]\n",
+ " db_names = db_names[:mgnify_max_hits]\n",
+ " msas.append(db_msas)\n",
+ " deletion_matrices.append(db_deletion_matrices)\n",
+ " names.append(db_names)\n",
+ " msa_size = len(set(db_msas))\n",
+ " print(f'{msa_size} Sequences Found in {db_name}')\n",
+ "\n",
+ " pickle.dump({\"msas\":msas,\n",
+ " \"deletion_matrices\":deletion_matrices,\n",
+ " \"names\":names}, open(pickled_msa_path,\"wb\"))\n",
+ " return msas, deletion_matrices, names"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "rowN0bVYLe9n",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Enter the amino acid sequence to fold ⬇️\n",
+ "import re\n",
+ "\n",
+ "# define sequence\n",
+ "sequence = 'PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK' #@param {type:\"string\"}\n",
+ "sequence = re.sub(\"[^A-Z:/]\", \"\", sequence.upper())\n",
+ "sequence = re.sub(\":+\",\":\",sequence)\n",
+ "sequence = re.sub(\"/+\",\"/\",sequence)\n",
+ "sequence = re.sub(\"^[:/]+\",\"\",sequence)\n",
+ "sequence = re.sub(\"[:/]+$\",\"\",sequence)\n",
+ "\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "jobname = re.sub(r'\\W+', '', jobname)\n",
+ "\n",
+ "# define number of copies\n",
+ "homooligomer = \"1\" #@param {type:\"string\"}\n",
+ "homooligomer = re.sub(\"[:/]+\",\":\",homooligomer)\n",
+ "homooligomer = re.sub(\"^[:/]+\",\"\",homooligomer)\n",
+ "homooligomer = re.sub(\"[:/]+$\",\"\",homooligomer)\n",
+ "\n",
+ "if len(homooligomer) == 0: homooligomer = \"1\"\n",
+ "homooligomer = re.sub(\"[^0-9:]\", \"\", homooligomer)\n",
+ "homooligomers = [int(h) for h in homooligomer.split(\":\")]\n",
+ "\n",
+ "#@markdown - `sequence` Specify protein sequence to be modelled.\n",
+ "#@markdown - Use `/` to specify intra-protein chainbreaks (for trimming regions within protein).\n",
+ "#@markdown - Use `:` to specify inter-protein chainbreaks (for modeling protein-protein hetero-complexes).\n",
+ "#@markdown - For example, sequence `AC/DE:FGH` will be modelled as polypeptides: `AC`, `DE` and `FGH`. A seperate MSA will be generates for `ACDE` and `FGH`.\n",
+ "#@markdown If `pair_msa` is enabled, `ACDE`'s MSA will be paired with `FGH`'s MSA.\n",
+ "#@markdown - `homooligomer` Define number of copies in a homo-oligomeric assembly.\n",
+ "#@markdown - Use `:` to specify different homooligomeric state (copy numer) for each component of the complex. \n",
+ "#@markdown - For example, **sequence:**`ABC:DEF`, **homooligomer:** `2:1`, the first protein `ABC` will be modeled as a homodimer (2 copies) and second `DEF` a monomer (1 copy).\n",
+ "\n",
+ "ori_sequence = sequence\n",
+ "sequence = sequence.replace(\"/\",\"\").replace(\":\",\"\")\n",
+ "seqs = ori_sequence.replace(\"/\",\"\").split(\":\")\n",
+ "\n",
+ "if len(seqs) != len(homooligomers):\n",
+ " if len(homooligomers) == 1:\n",
+ " homooligomers = [homooligomers[0]] * len(seqs)\n",
+ " homooligomer = \":\".join([str(h) for h in homooligomers])\n",
+ " else:\n",
+ " while len(seqs) > len(homooligomers):\n",
+ " homooligomers.append(1)\n",
+ " homooligomers = homooligomers[:len(seqs)]\n",
+ " homooligomer = \":\".join([str(h) for h in homooligomers])\n",
+ " print(\"WARNING: Mismatch between number of breaks ':' in 'sequence' and 'homooligomer' definition\")\n",
+ "\n",
+ "full_sequence = \"\".join([s*h for s,h in zip(seqs,homooligomers)])\n",
+ "\n",
+ "# prediction directory\n",
+ "output_dir = 'prediction_' + jobname + '_' + cf.get_hash(full_sequence)[:5]\n",
+ "os.makedirs(output_dir, exist_ok=True)\n",
+ "# delete existing files in working directory\n",
+ "for f in os.listdir(output_dir):\n",
+ " os.remove(os.path.join(output_dir, f))\n",
+ "\n",
+ "MIN_SEQUENCE_LENGTH = 16\n",
+ "MAX_SEQUENCE_LENGTH = 2500\n",
+ "\n",
+ "aatypes = set('ACDEFGHIKLMNPQRSTVWY') # 20 standard aatypes\n",
+ "if not set(full_sequence).issubset(aatypes):\n",
+ " raise Exception(f'Input sequence contains non-amino acid letters: {set(sequence) - aatypes}. AlphaFold only supports 20 standard amino acids as inputs.')\n",
+ "if len(full_sequence) < MIN_SEQUENCE_LENGTH:\n",
+ " raise Exception(f'Input sequence is too short: {len(full_sequence)} amino acids, while the minimum is {MIN_SEQUENCE_LENGTH}')\n",
+ "if len(full_sequence) > MAX_SEQUENCE_LENGTH:\n",
+ " raise Exception(f'Input sequence is too long: {len(full_sequence)} amino acids, while the maximum is {MAX_SEQUENCE_LENGTH}. Please use the full AlphaFold system for long sequences.')\n",
+ "\n",
+ "if len(full_sequence) > 1400:\n",
+ " print(f\"WARNING: For a typical Google-Colab-GPU (16G) session, the max total length is ~1400 residues. You are at {len(full_sequence)}! Run Alphafold may crash.\")\n",
+ "\n",
+ "print(f\"homooligomer: '{homooligomer}'\")\n",
+ "print(f\"total_length: '{len(full_sequence)}'\")\n",
+ "print(f\"working_directory: '{output_dir}'\")\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ITcPnLkLuDDE",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Search against genetic databases\n",
+ "#@markdown Once this cell has been executed, you will see\n",
+ "#@markdown statistics about the multiple sequence alignment \n",
+ "#@markdown (MSA) that will be used by AlphaFold. In particular, \n",
+ "#@markdown you’ll see how well each residue is covered by similar \n",
+ "#@markdown sequences in the MSA.\n",
+ "#@markdown (Note that the search against databases and the actual prediction can take some time, from minutes to hours, depending on the length of the protein and what type of GPU you are allocated by Colab.)\n",
+ "\n",
+ "#@markdown ---\n",
+ "msa_method = \"mmseqs2\" #@param [\"mmseqs2\",\"jackhmmer\",\"single_sequence\",\"precomputed\"]\n",
+ "#@markdown - `mmseqs2` - FAST method from [ColabFold](https://github.com/sokrypton/ColabFold)\n",
+ "#@markdown - `jackhmmer` - default method from Deepmind (SLOW, but may find more/less sequences).\n",
+ "#@markdown - `single_sequence` - use single sequence input\n",
+ "#@markdown - `precomputed` If you have previously run this notebook and saved the results,\n",
+ "#@markdown you can skip this step by uploading \n",
+ "#@markdown the previously generated `prediction_?????/msa.pickle`\n",
+ "\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown **custom msa options**\n",
+ "add_custom_msa = False #@param {type:\"boolean\"}\n",
+ "msa_format = \"fas\" #@param [\"fas\",\"a2m\",\"a3m\",\"sto\",\"psi\",\"clu\"]\n",
+ "#@markdown - `add_custom_msa` - If enabled, you'll get an option to upload your custom MSA in the specified `msa_format`. Note: Your MSA will be supplemented with those from 'mmseqs2' or 'jackhmmer', unless `msa_method` is set to 'single_sequence'.\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown **pair msa options**\n",
+ "\n",
+ "#@markdown Experimental option for protein complexes. Pairing currently only supported for proteins in same operon (prokaryotic genomes).\n",
+ "pair_mode = \"unpaired\" #@param [\"unpaired\",\"unpaired+paired\",\"paired\"] {type:\"string\"}\n",
+ "#@markdown - `unpaired` - generate seperate MSA for each protein.\n",
+ "#@markdown - `unpaired+paired` - attempt to pair sequences from the same operon within the genome. \n",
+ "#@markdown - `paired` - only use sequences that were sucessfully paired.\n",
+ "\n",
+ "#@markdown Options to prefilter each MSA before pairing. (It might help if there are any paralogs in the complex.)\n",
+ "pair_cov = 50 #@param [0,25,50,75,90] {type:\"raw\"}\n",
+ "pair_qid = 20 #@param [0,15,20,30,40,50] {type:\"raw\"}\n",
+ "#@markdown - `pair_cov` prefilter each MSA to minimum coverage with query (%) before pairing.\n",
+ "#@markdown - `pair_qid` prefilter each MSA to minimum sequence identity with query (%) before pairing.\n",
+ "\n",
+ "# --- Search against genetic databases ---\n",
+ "os.makedirs('tmp', exist_ok=True)\n",
+ "msas, deletion_matrices = [],[]\n",
+ "\n",
+ "if add_custom_msa:\n",
+ " print(f\"upload custom msa in '{msa_format}' format\")\n",
+ " msa_dict = files.upload()\n",
+ " lines = msa_dict[list(msa_dict.keys())[0]].decode()\n",
+ " \n",
+ " # convert to a3m\n",
+ " with open(f\"tmp/upload.{msa_format}\",\"w\") as tmp_upload:\n",
+ " tmp_upload.write(lines)\n",
+ " os.system(f\"reformat.pl {msa_format} a3m tmp/upload.{msa_format} tmp/upload.a3m\")\n",
+ " a3m_lines = open(\"tmp/upload.a3m\",\"r\").read()\n",
+ "\n",
+ " # parse\n",
+ " msa, mtx = parsers.parse_a3m(a3m_lines)\n",
+ " msas.append(msa)\n",
+ " deletion_matrices.append(mtx)\n",
+ "\n",
+ " if len(msas[0][0]) != len(sequence):\n",
+ " raise ValueError(\"ERROR: the length of msa does not match input sequence\")\n",
+ "\n",
+ "if msa_method == \"precomputed\":\n",
+ " print(\"upload precomputed pickled msa from previous run\")\n",
+ " pickled_msa_dict = files.upload()\n",
+ " msas_dict = pickle.loads(pickled_msa_dict[list(pickled_msa_dict.keys())[0]])\n",
+ " msas, deletion_matrices = (msas_dict[k] for k in ['msas', 'deletion_matrices'])\n",
+ "\n",
+ "elif msa_method == \"single_sequence\":\n",
+ " if len(msas) == 0:\n",
+ " msas.append([sequence])\n",
+ " deletion_matrices.append([[0]*len(sequence)])\n",
+ "\n",
+ "else:\n",
+ " seqs = ori_sequence.replace('/','').split(':')\n",
+ " _blank_seq = [\"-\" * len(seq) for seq in seqs]\n",
+ " _blank_mtx = [[0] * len(seq) for seq in seqs]\n",
+ " def _pad(ns,vals,mode):\n",
+ " if mode == \"seq\": _blank = _blank_seq.copy()\n",
+ " if mode == \"mtx\": _blank = _blank_mtx.copy()\n",
+ " if isinstance(ns, list):\n",
+ " for n,val in zip(ns,vals): _blank[n] = val\n",
+ " else: _blank[ns] = vals\n",
+ " if mode == \"seq\": return \"\".join(_blank)\n",
+ " if mode == \"mtx\": return sum(_blank,[])\n",
+ "\n",
+ " if len(seqs) == 1 or \"unpaired\" in pair_mode:\n",
+ " # gather msas\n",
+ " if msa_method == \"mmseqs2\":\n",
+ " prefix = cf.get_hash(\"\".join(seqs))\n",
+ " prefix = os.path.join('tmp',prefix)\n",
+ " print(f\"running mmseqs2\")\n",
+ " A3M_LINES = cf.run_mmseqs2(seqs, prefix, filter=True)\n",
+ "\n",
+ " for n, seq in enumerate(seqs):\n",
+ " # tmp directory\n",
+ " prefix = cf.get_hash(seq)\n",
+ " prefix = os.path.join('tmp',prefix)\n",
+ "\n",
+ " if msa_method == \"mmseqs2\":\n",
+ " # run mmseqs2\n",
+ " a3m_lines = A3M_LINES[n]\n",
+ " msa, mtx = parsers.parse_a3m(a3m_lines)\n",
+ " msas_, mtxs_ = [msa],[mtx]\n",
+ "\n",
+ " elif msa_method == \"jackhmmer\":\n",
+ " print(f\"running jackhmmer on seq_{n}\")\n",
+ " # run jackhmmer\n",
+ " msas_, mtxs_, names_ = ([sum(x,())] for x in run_jackhmmer(seq, prefix))\n",
+ " \n",
+ " # pad sequences\n",
+ " for msa_,mtx_ in zip(msas_,mtxs_):\n",
+ " msa,mtx = [sequence],[[0]*len(sequence)] \n",
+ " for s,m in zip(msa_,mtx_):\n",
+ " msa.append(_pad(n,s,\"seq\"))\n",
+ " mtx.append(_pad(n,m,\"mtx\"))\n",
+ "\n",
+ " msas.append(msa)\n",
+ " deletion_matrices.append(mtx)\n",
+ "\n",
+ " ####################################################################################\n",
+ " # PAIR_MSA\n",
+ " ####################################################################################\n",
+ " if len(seqs) > 1 and (pair_mode == \"paired\" or pair_mode == \"unpaired+paired\"):\n",
+ " print(\"attempting to pair some sequences...\")\n",
+ "\n",
+ " if msa_method == \"mmseqs2\":\n",
+ " prefix = cf.get_hash(\"\".join(seqs))\n",
+ " prefix = os.path.join('tmp',prefix)\n",
+ " print(f\"running mmseqs2_noenv_nofilter on all seqs\")\n",
+ " A3M_LINES = cf.run_mmseqs2(seqs, prefix, use_env=False, use_filter=False)\n",
+ "\n",
+ " _data = []\n",
+ " for a in range(len(seqs)):\n",
+ " print(f\"prepping seq_{a}\")\n",
+ " _seq = seqs[a]\n",
+ " _prefix = os.path.join('tmp',cf.get_hash(_seq))\n",
+ "\n",
+ " if msa_method == \"mmseqs2\":\n",
+ " a3m_lines = A3M_LINES[a]\n",
+ " _msa, _mtx, _lab = pairmsa.parse_a3m(a3m_lines,\n",
+ " filter_qid=pair_qid/100,\n",
+ " filter_cov=pair_cov/100)\n",
+ "\n",
+ " elif msa_method == \"jackhmmer\":\n",
+ " _msas, _mtxs, _names = run_jackhmmer(_seq, _prefix)\n",
+ " _msa, _mtx, _lab = pairmsa.get_uni_jackhmmer(_msas[0], _mtxs[0], _names[0],\n",
+ " filter_qid=pair_qid/100,\n",
+ " filter_cov=pair_cov/100)\n",
+ "\n",
+ " if len(_msa) > 1:\n",
+ " _data.append(pairmsa.hash_it(_msa, _lab, _mtx, call_uniprot=False))\n",
+ " else:\n",
+ " _data.append(None)\n",
+ " \n",
+ " Ln = len(seqs)\n",
+ " O = [[None for _ in seqs] for _ in seqs]\n",
+ " for a in range(Ln):\n",
+ " if _data[a] is not None:\n",
+ " for b in range(a+1,Ln):\n",
+ " if _data[b] is not None:\n",
+ " print(f\"attempting pairwise stitch for {a} {b}\") \n",
+ " O[a][b] = pairmsa._stitch(_data[a],_data[b])\n",
+ " _seq_a, _seq_b, _mtx_a, _mtx_b = (*O[a][b][\"seq\"],*O[a][b][\"mtx\"])\n",
+ "\n",
+ " ##############################################\n",
+ " # filter to remove redundant sequences\n",
+ " ##############################################\n",
+ " ok = []\n",
+ " with open(\"tmp/tmp.fas\",\"w\") as fas_file:\n",
+ " fas_file.writelines([f\">{n}\\n{a+b}\\n\" for n,(a,b) in enumerate(zip(_seq_a,_seq_b))])\n",
+ " os.system(\"hhfilter -maxseq 1000000 -i tmp/tmp.fas -o tmp/tmp.id90.fas -id 90\")\n",
+ " for line in open(\"tmp/tmp.id90.fas\",\"r\"):\n",
+ " if line.startswith(\">\"): ok.append(int(line[1:]))\n",
+ " ############################################## \n",
+ " print(f\"found {len(_seq_a)} pairs ({len(ok)} after filtering)\")\n",
+ "\n",
+ " if len(_seq_a) > 0:\n",
+ " msa,mtx = [sequence],[[0]*len(sequence)]\n",
+ " for s_a,s_b,m_a,m_b in zip(_seq_a, _seq_b, _mtx_a, _mtx_b):\n",
+ " msa.append(_pad([a,b],[s_a,s_b],\"seq\"))\n",
+ " mtx.append(_pad([a,b],[m_a,m_b],\"mtx\"))\n",
+ " msas.append(msa)\n",
+ " deletion_matrices.append(mtx)\n",
+ " \n",
+ " '''\n",
+ " # triwise stitching (WIP)\n",
+ " if Ln > 2:\n",
+ " for a in range(Ln):\n",
+ " for b in range(a+1,Ln):\n",
+ " for c in range(b+1,Ln):\n",
+ " if O[a][b] is not None and O[b][c] is not None:\n",
+ " print(f\"attempting triwise stitch for {a} {b} {c}\")\n",
+ " list_ab = O[a][b][\"lab\"][1]\n",
+ " list_bc = O[b][c][\"lab\"][0]\n",
+ " msa,mtx = [sequence],[[0]*len(sequence)]\n",
+ " for i,l_b in enumerate(list_ab):\n",
+ " if l_b in list_bc:\n",
+ " j = list_bc.index(l_b)\n",
+ " s_a = O[a][b][\"seq\"][0][i]\n",
+ " s_b = O[a][b][\"seq\"][1][i]\n",
+ " s_c = O[b][c][\"seq\"][1][j]\n",
+ "\n",
+ " m_a = O[a][b][\"mtx\"][0][i]\n",
+ " m_b = O[a][b][\"mtx\"][1][i]\n",
+ " m_c = O[b][c][\"mtx\"][1][j]\n",
+ "\n",
+ " msa.append(_pad([a,b,c],[s_a,s_b,s_c],\"seq\"))\n",
+ " mtx.append(_pad([a,b,c],[m_a,m_b,m_c],\"mtx\"))\n",
+ " if len(msa) > 1:\n",
+ " msas.append(msa)\n",
+ " deletion_matrices.append(mtx)\n",
+ " print(f\"found {len(msa)} triplets\") \n",
+ " '''\n",
+ "####################################################################################\n",
+ "####################################################################################\n",
+ "\n",
+ "# save MSA as pickle\n",
+ "pickle.dump({\"msas\":msas,\"deletion_matrices\":deletion_matrices},\n",
+ " open(os.path.join(output_dir,\"msa.pickle\"),\"wb\"))\n",
+ "\n",
+ "make_msa_plot = len(msas[0]) > 1\n",
+ "if make_msa_plot:\n",
+ " plt = cf.plot_msas(msas, ori_sequence)\n",
+ " plt.savefig(os.path.join(output_dir,\"msa_coverage.png\"), bbox_inches = 'tight', dpi=200)\n",
+ " plt.show()\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "bQe3KeyTcv0n",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title run alphafold\n",
+ "num_relax = \"None\"\n",
+ "rank_by = \"pLDDT\" #@param [\"pLDDT\",\"pTMscore\"]\n",
+ "use_turbo = True #@param {type:\"boolean\"}\n",
+ "max_msa = \"512:1024\" #@param [\"512:1024\", \"256:512\", \"128:256\", \"64:128\", \"32:64\"]\n",
+ "max_msa_clusters, max_extra_msa = [int(x) for x in max_msa.split(\":\")]\n",
+ "\n",
+ "\n",
+ "\n",
+ "#@markdown - `rank_by` specify metric to use for ranking models (For protein-protein complexes, we recommend pTMscore)\n",
+ "#@markdown - `use_turbo` introduces a few modifications (compile once, swap params, adjust max_msa) to speedup and reduce memory requirements. Disable for default behavior.\n",
+ "#@markdown - `max_msa` defines: `max_msa_clusters:max_extra_msa` number of sequences to use. When adjusting after GPU crash, be sure to `Runtime` → `Restart runtime`. (Lowering will reduce GPU requirements, but may result in poor model quality. This option ignored if `use_turbo` is disabled)\n",
+ "show_images = True #@param {type:\"boolean\"}\n",
+ "#@markdown - `show_images` To make things more exciting we show images of the predicted structures as they are being generated. (WARNING: the order of images displayed does not reflect any ranking).\n",
+ "#@markdown ---\n",
+ "#@markdown #### Sampling options\n",
+ "#@markdown There are two stochastic parts of the pipeline. Within the feature generation (choice of cluster centers) and within the model (dropout). \n",
+ "#@markdown To get structure diversity, you can iterate through a fixed number of random_seeds (using `num_samples`) and/or enable dropout (using `is_training`).\n",
+ "\n",
+ "num_models = 5 #@param [1,2,3,4,5] {type:\"raw\"}\n",
+ "use_ptm = True #@param {type:\"boolean\"}\n",
+ "num_ensemble = 1 #@param [1,8] {type:\"raw\"}\n",
+ "max_recycles = 3 #@param [1,3,6,12,24,48] {type:\"raw\"}\n",
+ "tol = 0 #@param [0,0.1,0.5,1] {type:\"raw\"}\n",
+ "is_training = False #@param {type:\"boolean\"}\n",
+ "num_samples = 1 #@param [1,2,4,8,16,32] {type:\"raw\"}\n",
+ "#@markdown - `num_models` specify how many model params to try. (5 recommended)\n",
+ "#@markdown - `use_ptm` uses Deepmind's `ptm` finetuned model parameters to get PAE per structure. Disable to use the original model params. (Disabling may give alternative structures.)\n",
+ "#@markdown - `num_ensemble` the trunk of the network is run multiple times with different random choices for the MSA cluster centers. (`1`=`default`, `8`=`casp14 setting`)\n",
+ "#@markdown - `max_recycles` controls the maximum number of times the structure is fed back into the neural network for refinement. (3 recommended)\n",
+ "#@markdown - `tol` tolerance for deciding when to stop (CA-RMS between recycles)\n",
+ "#@markdown - `is_training` enables the stochastic part of the model (dropout), when coupled with `num_samples` can be used to \"sample\" a diverse set of structures.\n",
+ "#@markdown - `num_samples` number of random_seeds to try.\n",
+ "subsample_msa = True #@param {type:\"boolean\"}\n",
+ "#@markdown - `subsample_msa` subsample large MSA to `3E7/length` sequences to avoid crashing the preprocessing protocol. (This option ignored if `use_turbo` is disabled.)\n",
+ "\n",
+ "save_pae_json = True \n",
+ "save_tmp_pdb = True\n",
+ "\n",
+ "\n",
+ "if use_ptm == False and rank_by == \"pTMscore\":\n",
+ " print(\"WARNING: models will be ranked by pLDDT, 'use_ptm' is needed to compute pTMscore\")\n",
+ " rank_by = \"pLDDT\"\n",
+ "\n",
+ "#############################\n",
+ "# delete old files\n",
+ "#############################\n",
+ "for f in os.listdir(output_dir):\n",
+ " if \"rank_\" in f:\n",
+ " os.remove(os.path.join(output_dir, f))\n",
+ "\n",
+ "#############################\n",
+ "# homooligomerize\n",
+ "#############################\n",
+ "lengths = [len(seq) for seq in seqs]\n",
+ "msas_mod, deletion_matrices_mod = cf.homooligomerize_heterooligomer(msas, deletion_matrices,\n",
+ " lengths, homooligomers)\n",
+ "#############################\n",
+ "# define input features\n",
+ "#############################\n",
+ "def _placeholder_template_feats(num_templates_, num_res_):\n",
+ " return {\n",
+ " 'template_aatype': np.zeros([num_templates_, num_res_, 22], np.float32),\n",
+ " 'template_all_atom_masks': np.zeros([num_templates_, num_res_, 37, 3], np.float32),\n",
+ " 'template_all_atom_positions': np.zeros([num_templates_, num_res_, 37], np.float32),\n",
+ " 'template_domain_names': np.zeros([num_templates_], np.float32),\n",
+ " 'template_sum_probs': np.zeros([num_templates_], np.float32),\n",
+ " }\n",
+ "\n",
+ "num_res = len(full_sequence)\n",
+ "feature_dict = {}\n",
+ "feature_dict.update(pipeline.make_sequence_features(full_sequence, 'test', num_res))\n",
+ "feature_dict.update(pipeline.make_msa_features(msas_mod, deletion_matrices=deletion_matrices_mod))\n",
+ "if not use_turbo:\n",
+ " feature_dict.update(_placeholder_template_feats(0, num_res))\n",
+ "\n",
+ "def do_subsample_msa(F, random_seed=0):\n",
+ " '''subsample msa to avoid running out of memory'''\n",
+ " N = len(F[\"msa\"])\n",
+ " L = len(F[\"residue_index\"])\n",
+ " N_ = int(3E7/L)\n",
+ " if N > N_:\n",
+ " print(f\"whhhaaa... too many sequences ({N}) subsampling to {N_}\")\n",
+ " np.random.seed(random_seed)\n",
+ " idx = np.append(0,np.random.permutation(np.arange(1,N)))[:N_]\n",
+ " F_ = {}\n",
+ " F_[\"msa\"] = F[\"msa\"][idx]\n",
+ " F_[\"deletion_matrix_int\"] = F[\"deletion_matrix_int\"][idx]\n",
+ " F_[\"num_alignments\"] = np.full_like(F[\"num_alignments\"],N_)\n",
+ " for k in ['aatype', 'between_segment_residues',\n",
+ " 'domain_name', 'residue_index',\n",
+ " 'seq_length', 'sequence']:\n",
+ " F_[k] = F[k]\n",
+ " return F_\n",
+ " else:\n",
+ " return F\n",
+ "\n",
+ "################################\n",
+ "# set chain breaks\n",
+ "################################\n",
+ "Ls = []\n",
+ "for seq,h in zip(ori_sequence.split(\":\"),homooligomers):\n",
+ " Ls += [len(s) for s in seq.split(\"/\")] * h\n",
+ "Ls_plot = sum([[len(seq)]*h for seq,h in zip(seqs,homooligomers)],[])\n",
+ "feature_dict['residue_index'] = cf.chain_break(feature_dict['residue_index'], Ls)\n",
+ "\n",
+ "###########################\n",
+ "# run alphafold\n",
+ "###########################\n",
+ "def parse_results(prediction_result, processed_feature_dict):\n",
+ " b_factors = prediction_result['plddt'][:,None] * prediction_result['structure_module']['final_atom_mask'] \n",
+ " dist_bins = jax.numpy.append(0,prediction_result[\"distogram\"][\"bin_edges\"])\n",
+ " dist_mtx = dist_bins[prediction_result[\"distogram\"][\"logits\"].argmax(-1)]\n",
+ " contact_mtx = jax.nn.softmax(prediction_result[\"distogram\"][\"logits\"])[:,:,dist_bins < 8].sum(-1)\n",
+ "\n",
+ " out = {\"unrelaxed_protein\": protein.from_prediction(processed_feature_dict, prediction_result, b_factors=b_factors),\n",
+ " \"plddt\": prediction_result['plddt'],\n",
+ " \"pLDDT\": prediction_result['plddt'].mean(),\n",
+ " \"dists\": dist_mtx,\n",
+ " \"adj\": contact_mtx}\n",
+ "\n",
+ " if \"ptm\" in prediction_result:\n",
+ " out.update({\"pae\": prediction_result['predicted_aligned_error'],\n",
+ " \"pTMscore\": prediction_result['ptm']})\n",
+ " return out\n",
+ "\n",
+ "model_names = ['model_1', 'model_2', 'model_3', 'model_4', 'model_5'][:num_models]\n",
+ "total = len(model_names) * num_samples\n",
+ "with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " #######################################################################\n",
+ " # precompile model and recompile only if length changes\n",
+ " #######################################################################\n",
+ " if use_turbo:\n",
+ " name = \"model_5_ptm\" if use_ptm else \"model_5\"\n",
+ " N = len(feature_dict[\"msa\"])\n",
+ " L = len(feature_dict[\"residue_index\"])\n",
+ " compiled = (N, L, use_ptm, max_recycles, tol, num_ensemble, max_msa, is_training)\n",
+ " if \"COMPILED\" in dir():\n",
+ " if COMPILED != compiled: recompile = True\n",
+ " else: recompile = True\n",
+ " if recompile:\n",
+ " cf.clear_mem(\"gpu\")\n",
+ " cfg = config.model_config(name) \n",
+ "\n",
+ " # set size of msa (to reduce memory requirements)\n",
+ " msa_clusters = min(N, max_msa_clusters)\n",
+ " cfg.data.eval.max_msa_clusters = msa_clusters\n",
+ " cfg.data.common.max_extra_msa = max(min(N-msa_clusters,max_extra_msa),1)\n",
+ "\n",
+ " cfg.data.common.num_recycle = max_recycles\n",
+ " cfg.model.num_recycle = max_recycles\n",
+ " cfg.model.recycle_tol = tol\n",
+ " cfg.data.eval.num_ensemble = num_ensemble\n",
+ "\n",
+ " params = data.get_model_haiku_params(name,'./alphafold/data')\n",
+ " model_runner = model.RunModel(cfg, params, is_training=is_training)\n",
+ " COMPILED = compiled\n",
+ " recompile = False\n",
+ "\n",
+ " else:\n",
+ " cf.clear_mem(\"gpu\")\n",
+ " recompile = True\n",
+ "\n",
+ " # cleanup\n",
+ " if \"outs\" in dir(): del outs\n",
+ " outs = {}\n",
+ " cf.clear_mem(\"cpu\") \n",
+ "\n",
+ " #######################################################################\n",
+ " def report(key):\n",
+ " pbar.update(n=1)\n",
+ " o = outs[key]\n",
+ " line = f\"{key} recycles:{o['recycles']} tol:{o['tol']:.2f} pLDDT:{o['pLDDT']:.2f}\"\n",
+ " if use_ptm: line += f\" pTMscore:{o['pTMscore']:.2f}\"\n",
+ " print(line)\n",
+ " if show_images:\n",
+ " fig = cf.plot_protein(o['unrelaxed_protein'], Ls=Ls_plot, dpi=100)\n",
+ " plt.show()\n",
+ " if save_tmp_pdb:\n",
+ " tmp_pdb_path = os.path.join(output_dir,f'unranked_{key}_unrelaxed.pdb')\n",
+ " pdb_lines = protein.to_pdb(o['unrelaxed_protein'])\n",
+ " with open(tmp_pdb_path, 'w') as f: f.write(pdb_lines)\n",
+ "\n",
+ " if use_turbo:\n",
+ " # go through each random_seed\n",
+ " for seed in range(num_samples):\n",
+ " \n",
+ " # prep input features\n",
+ " if subsample_msa:\n",
+ " sampled_feats_dict = do_subsample_msa(feature_dict, random_seed=seed) \n",
+ " processed_feature_dict = model_runner.process_features(sampled_feats_dict, random_seed=seed)\n",
+ " else:\n",
+ " processed_feature_dict = model_runner.process_features(feature_dict, random_seed=seed)\n",
+ "\n",
+ " # go through each model\n",
+ " for num, model_name in enumerate(model_names):\n",
+ " name = model_name+\"_ptm\" if use_ptm else model_name\n",
+ " key = f\"{name}_seed_{seed}\"\n",
+ " pbar.set_description(f'Running {key}')\n",
+ "\n",
+ " # replace model parameters\n",
+ " params = data.get_model_haiku_params(name, './alphafold/data')\n",
+ " for k in model_runner.params.keys():\n",
+ " model_runner.params[k] = params[k]\n",
+ "\n",
+ " # predict\n",
+ " prediction_result, (r, t) = cf.to(model_runner.predict(processed_feature_dict, random_seed=seed),\"cpu\")\n",
+ "\n",
+ " # save results\n",
+ " outs[key] = parse_results(prediction_result, processed_feature_dict)\n",
+ " outs[key].update({\"recycles\":r, \"tol\":t})\n",
+ " report(key)\n",
+ "\n",
+ " del prediction_result, params\n",
+ " del sampled_feats_dict, processed_feature_dict\n",
+ "\n",
+ " else: \n",
+ " # go through each model\n",
+ " for num, model_name in enumerate(model_names):\n",
+ " name = model_name+\"_ptm\" if use_ptm else model_name\n",
+ " params = data.get_model_haiku_params(name, './alphafold/data') \n",
+ " cfg = config.model_config(name)\n",
+ " cfg.data.common.num_recycle = cfg.model.num_recycle = max_recycles\n",
+ " cfg.model.recycle_tol = tol\n",
+ " cfg.data.eval.num_ensemble = num_ensemble\n",
+ " model_runner = model.RunModel(cfg, params, is_training=is_training)\n",
+ "\n",
+ " # go through each random_seed\n",
+ " for seed in range(num_samples):\n",
+ " key = f\"{name}_seed_{seed}\"\n",
+ " pbar.set_description(f'Running {key}')\n",
+ " processed_feature_dict = model_runner.process_features(feature_dict, random_seed=seed)\n",
+ " prediction_result, (r, t) = cf.to(model_runner.predict(processed_feature_dict, random_seed=seed),\"cpu\")\n",
+ " outs[key] = parse_results(prediction_result, processed_feature_dict)\n",
+ " outs[key].update({\"recycles\":r, \"tol\":t})\n",
+ " report(key)\n",
+ "\n",
+ " # cleanup\n",
+ " del processed_feature_dict, prediction_result\n",
+ "\n",
+ " del params, model_runner, cfg\n",
+ " cf.clear_mem(\"gpu\")\n",
+ "\n",
+ " # delete old files\n",
+ " for f in os.listdir(output_dir):\n",
+ " if \"rank\" in f:\n",
+ " os.remove(os.path.join(output_dir, f))\n",
+ "\n",
+ " # Find the best model according to the mean pLDDT.\n",
+ " model_rank = list(outs.keys())\n",
+ " model_rank = [model_rank[i] for i in np.argsort([outs[x][rank_by] for x in model_rank])[::-1]]\n",
+ "\n",
+ " # Write out the prediction\n",
+ " for n,key in enumerate(model_rank):\n",
+ " prefix = f\"rank_{n+1}_{key}\" \n",
+ " pred_output_path = os.path.join(output_dir,f'{prefix}_unrelaxed.pdb')\n",
+ " fig = cf.plot_protein(outs[key][\"unrelaxed_protein\"], Ls=Ls_plot, dpi=200)\n",
+ " plt.savefig(os.path.join(output_dir,f'{prefix}.png'), bbox_inches = 'tight')\n",
+ " plt.close(fig)\n",
+ "\n",
+ " pdb_lines = protein.to_pdb(outs[key][\"unrelaxed_protein\"])\n",
+ " with open(pred_output_path, 'w') as f:\n",
+ " f.write(pdb_lines)\n",
+ " \n",
+ "############################################################\n",
+ "print(f\"model rank based on {rank_by}\")\n",
+ "for n,key in enumerate(model_rank):\n",
+ " print(f\"rank_{n+1}_{key} {rank_by}:{outs[key][rank_by]:.2f}\")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "PnMog4kHUztt",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Refine structures with Amber-Relax (Optional)\n",
+ "#@markdown If side-chain bond geometry is important to you, enable Amber-Relax by specifying how many top ranked structures you want relaxed. By default, we disable Amber-Relax since it barely moves the main-chain (backbone) structure and can overall double the runtime.\n",
+ "num_relax = \"None\" #@param [\"None\", \"Top1\", \"Top5\", \"All\"] {type:\"string\"}\n",
+ "if num_relax == \"None\":\n",
+ " num_relax = 0\n",
+ "elif num_relax == \"Top1\":\n",
+ " num_relax = 1\n",
+ "elif num_relax == \"Top5\":\n",
+ " num_relax = 5\n",
+ "else:\n",
+ " num_relax = len(model_names) * num_samples\n",
+ "\n",
+ "#@markdown - `num_relax` specify how many of the top ranked structures to relax\n",
+ "if num_relax > 0 and not os.path.isfile(\"stereo_chemical_props.txt\"):\n",
+ " try:\n",
+ " total = 45\n",
+ " with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " pbar.set_description(f'INSTALL AMBER')\n",
+ " with io.capture_output() as captured:\n",
+ " # Install OpenMM and pdbfixer.\n",
+ " %shell rm -rf /opt/conda\n",
+ " %shell wget -q -P /tmp \\\n",
+ " https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \\\n",
+ " && bash /tmp/Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda \\\n",
+ " && rm /tmp/Miniconda3-latest-Linux-x86_64.sh\n",
+ " pbar.update(4)\n",
+ "\n",
+ " PATH=%env PATH\n",
+ " %env PATH=/opt/conda/bin:{PATH}\n",
+ " %shell conda update -qy conda \\\n",
+ " && conda install -qy -c conda-forge \\\n",
+ " python={python_version} \\\n",
+ " openmm=7.5.1 \\\n",
+ " pdbfixer\n",
+ " pbar.update(40)\n",
+ "\n",
+ " %shell wget -q -P /content \\\n",
+ " https://git.scicore.unibas.ch/schwede/openstructure/-/raw/7102c63615b64735c4941278d92b554ec94415f8/modules/mol/alg/src/stereo_chemical_props.txt\n",
+ " pbar.update(1)\n",
+ " %shell mkdir -p /content/alphafold/common\n",
+ " %shell cp -f /content/stereo_chemical_props.txt /content/alphafold/common\n",
+ "\n",
+ " # Apply OpenMM patch.\n",
+ " %shell pushd /opt/conda/lib/python{python_version}/site-packages/ && \\\n",
+ " patch -p0 < /content/alphafold/docker/openmm.patch && \\\n",
+ " popd\n",
+ "\n",
+ " except subprocess.CalledProcessError:\n",
+ " print(captured)\n",
+ " raise\n",
+ "\n",
+ "if num_relax > 0:\n",
+ " if \"relax\" not in dir():\n",
+ " # add conda environment to path\n",
+ " sys.path.append(f\"/opt/conda/lib/python{python_version}/site-packages\")\n",
+ " \n",
+ " # import libraries\n",
+ " from alphafold.relax import relax\n",
+ " from alphafold.relax import utils\n",
+ "\n",
+ " with tqdm.notebook.tqdm(total=num_relax, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " pbar.set_description(f'AMBER relaxation')\n",
+ " for n,key in enumerate(model_rank):\n",
+ " if n < num_relax:\n",
+ " prefix = f\"rank_{n+1}_{key}\" \n",
+ " pred_output_path = os.path.join(output_dir,f'{prefix}_relaxed.pdb')\n",
+ " if not os.path.isfile(pred_output_path):\n",
+ " amber_relaxer = relax.AmberRelaxation(\n",
+ " max_iterations=0,\n",
+ " tolerance=2.39,\n",
+ " stiffness=10.0,\n",
+ " exclude_residues=[],\n",
+ " max_outer_iterations=20)\n",
+ " relaxed_pdb_lines, _, _ = amber_relaxer.process(prot=outs[key][\"unrelaxed_protein\"]) \n",
+ " with open(pred_output_path, 'w') as f:\n",
+ " f.write(relaxed_pdb_lines)\n",
+ " pbar.update(n=1)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KAZj6CBZTkJM",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "rank_num = 1 #@param [\"1\", \"2\", \"3\", \"4\", \"5\"] {type:\"raw\"}\n",
+ "color = \"lDDT\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "key = model_rank[rank_num-1]\n",
+ "prefix = f\"rank_{rank_num}_{key}\" \n",
+ "pred_output_path = os.path.join(output_dir,f'{prefix}_relaxed.pdb') \n",
+ "if not os.path.isfile(pred_output_path):\n",
+ " pred_output_path = os.path.join(output_dir,f'{prefix}_unrelaxed.pdb') \n",
+ "\n",
+ "cf.show_pdb(pred_output_path, show_sidechains, show_mainchains, color, Ls=Ls_plot).show()\n",
+ "if color == \"lDDT\": cf.plot_plddt_legend().show() \n",
+ "if use_ptm:\n",
+ " cf.plot_confidence(outs[key][\"plddt\"], outs[key][\"pae\"], Ls=Ls_plot).show()\n",
+ "else:\n",
+ " cf.plot_confidence(outs[key][\"plddt\"], Ls=Ls_plot).show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "XzK2Wve12GCk",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Extra outputs\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "save_to_txt = True #@param {type:\"boolean\"}\n",
+ "save_pae_json = True #@param {type:\"boolean\"}\n",
+ "#@markdown - save data used to generate contact and distogram plots below to text file (pae values can be found in json file if `use_ptm` is enabled)\n",
+ "\n",
+ "if use_ptm:\n",
+ " print(\"predicted alignment error\")\n",
+ " cf.plot_paes([outs[k][\"pae\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ " plt.savefig(os.path.join(output_dir,f'predicted_alignment_error.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ " plt.show()\n",
+ "\n",
+ "print(\"predicted contacts\")\n",
+ "cf.plot_adjs([outs[k][\"adj\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ "plt.savefig(os.path.join(output_dir,f'predicted_contacts.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ "plt.show()\n",
+ "\n",
+ "print(\"predicted distogram\")\n",
+ "cf.plot_dists([outs[k][\"dists\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ "plt.savefig(os.path.join(output_dir,f'predicted_distogram.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ "plt.show()\n",
+ "\n",
+ "print(\"predicted LDDT\")\n",
+ "cf.plot_plddts([outs[k][\"plddt\"] for k in model_rank], Ls=Ls_plot, dpi=dpi)\n",
+ "plt.savefig(os.path.join(output_dir,f'predicted_LDDT.png'), bbox_inches = 'tight', dpi=np.maximum(200,dpi))\n",
+ "plt.show()\n",
+ "\n",
+ "def do_save_to_txt(filename, adj, dists):\n",
+ " adj = np.asarray(adj)\n",
+ " dists = np.asarray(dists)\n",
+ " L = len(adj)\n",
+ " with open(filename,\"w\") as out:\n",
+ " out.write(\"i\\tj\\taa_i\\taa_j\\tp(cbcb<8)\\tmaxdistbin\\n\")\n",
+ " for i in range(L):\n",
+ " for j in range(i+1,L):\n",
+ " if dists[i][j] < 21.68 or adj[i][j] >= 0.001:\n",
+ " line = f\"{i+1}\\t{j+1}\\t{full_sequence[i]}\\t{full_sequence[j]}\\t{adj[i][j]:.3f}\"\n",
+ " line += f\"\\t>{dists[i][j]:.2f}\" if dists[i][j] == 21.6875 else f\"\\t{dists[i][j]:.2f}\"\n",
+ " out.write(f\"{line}\\n\")\n",
+ "\n",
+ "for n,key in enumerate(model_rank):\n",
+ " if save_to_txt:\n",
+ " txt_filename = os.path.join(output_dir,f'rank_{n+1}_{key}.raw.txt')\n",
+ " do_save_to_txt(txt_filename,adj=outs[key][\"adj\"],dists=outs[key][\"dists\"])\n",
+ "\n",
+ " if use_ptm and save_pae_json:\n",
+ " pae = outs[key][\"pae\"]\n",
+ " max_pae = pae.max()\n",
+ " # Save pLDDT and predicted aligned error (if it exists)\n",
+ " pae_output_path = os.path.join(output_dir,f'rank_{n+1}_{key}_pae.json')\n",
+ " # Save predicted aligned error in the same format as the AF EMBL DB\n",
+ " rounded_errors = np.round(np.asarray(pae), decimals=1)\n",
+ " indices = np.indices((len(rounded_errors), len(rounded_errors))) + 1\n",
+ " indices_1 = indices[0].flatten().tolist()\n",
+ " indices_2 = indices[1].flatten().tolist()\n",
+ " pae_data = json.dumps([{\n",
+ " 'residue1': indices_1,\n",
+ " 'residue2': indices_2,\n",
+ " 'distance': rounded_errors.flatten().tolist(),\n",
+ " 'max_predicted_aligned_error': max_pae.item()\n",
+ " }],\n",
+ " indent=None,\n",
+ " separators=(',', ':'))\n",
+ " with open(pae_output_path, 'w') as f:\n",
+ " f.write(pae_data)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Riekgf0KQv_3",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Download prediction\n",
+ "\n",
+ "#@markdown Once this cell has been executed, a zip-archive with \n",
+ "#@markdown the obtained prediction will be automatically downloaded \n",
+ "#@markdown to your computer.\n",
+ "\n",
+ "# add settings file\n",
+ "settings_path = os.path.join(output_dir,\"settings.txt\")\n",
+ "with open(settings_path, \"w\") as text_file:\n",
+ " text_file.write(f\"notebook=https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/beta/AlphaFold2_advanced.ipynb\\n\")\n",
+ " text_file.write(f\"sequence={ori_sequence}\\n\")\n",
+ " text_file.write(f\"msa_method={msa_method}\\n\")\n",
+ " if add_custom_msa:\n",
+ " text_file.write(f\"add_custom_msa={add_custom_msa} msa_format={msa_format}\\n\")\n",
+ " text_file.write(f\"homooligomer={homooligomer}\\n\")\n",
+ "\n",
+ " text_file.write(f\"pair_mode={pair_mode}\\n\")\n",
+ " if pair_mode != \"unpaired\":\n",
+ " text_file.write(f\"pair_cov={pair_cov}\\n\")\n",
+ " text_file.write(f\"pair_qid={pair_qid}\\n\")\n",
+ "\n",
+ " text_file.write(f\"max_msa={max_msa}\\n\")\n",
+ " text_file.write(f\"subsample_msa={subsample_msa}\\n\") \n",
+ " text_file.write(f\"num_relax={num_relax}\\n\")\n",
+ " text_file.write(f\"use_turbo={use_turbo}\\n\")\n",
+ " text_file.write(f\"use_ptm={use_ptm}\\n\")\n",
+ " text_file.write(f\"rank_by={rank_by}\\n\")\n",
+ " text_file.write(f\"num_models={num_models}\\n\")\n",
+ " text_file.write(f\"num_samples={num_samples}\\n\")\n",
+ " text_file.write(f\"num_ensemble={num_ensemble}\\n\")\n",
+ " text_file.write(f\"max_recycles={max_recycles}\\n\")\n",
+ " text_file.write(f\"tol={tol}\\n\")\n",
+ " text_file.write(f\"is_training={is_training}\\n\")\n",
+ " text_file.write(f\"use_templates=False\\n\")\n",
+ " text_file.write(f\"-------------------------------------------------\\n\")\n",
+ "\n",
+ " for n,key in enumerate(model_rank):\n",
+ " line = f\"rank_{n+1}_{key} pLDDT:{outs[key]['pLDDT']:.2f}\" + f\" pTMscore:{outs[key]['pTMscore']:.4f}\" if use_ptm else \"\"\n",
+ " text_file.write(line+\"\\n\")\n",
+ "\n",
+ "# --- Download the predictions ---\n",
+ "!zip -FSr {output_dir}.zip {output_dir}\n",
+ "files.download(f'{output_dir}.zip')"
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/AlphaFold2_complexes.ipynb b/data/beta/AlphaFold2_complexes.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..dd8d330867059e39e380393606ff66d9cace2265
--- /dev/null
+++ b/data/beta/AlphaFold2_complexes.ipynb
@@ -0,0 +1,647 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "name": "AlphaFold2_complexes.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "machine_shape": "hm",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G4yBrceuFbf3"
+ },
+ "source": [
+ "#AlphaFold2_complexes\n",
+ "\n",
+ "---------\n",
+ "**UPDATE** (Aug. 13, 2021)\n",
+ "\n",
+ "This notebook is being retired and no longer updated. The functionality for complex prediction (including going beyond dimers) has been integrated in our [new advanced notebook](https://github.com/sokrypton/ColabFold/blob/main/beta/AlphaFold2_advanced.ipynb).\n",
+ "\n",
+ "---------\n",
+ "\n",
+ "Credit to Minkyung Baek @minkbaek and Yoshitaka Moriwaki @Ag_smith for initially showing protein-complex prediction works in alphafold2.\n",
+ "- https://twitter.com/minkbaek/status/1417538291709071362\n",
+ "- https://twitter.com/Ag_smith/status/1417063635000598528\n",
+ "\n",
+ "- [script](https://github.com/RosettaCommons/RoseTTAFold/blob/main/example/complex_modeling/make_joint_MSA_bacterial.py) from rosettafold for paired alignment generation\n",
+ "\n",
+ "**Instructions**\n",
+ "- For *monomers* and *homo-oligomers*, see this [notebook](https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/AlphaFold2.ipynb).\n",
+ "- For prokaryotic protein complexes (found in operons), we recommend using the `pair_msa` option.\n",
+ "\n",
+ "\n",
+ "**Limitations**\n",
+ "- This notebook does NOT use templates or amber relax at the end for refinement.\n",
+ "- For a typical Google-Colab-GPU (16G) session, the max total length is **1400 residues**.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kOblAo-xetgx",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Input protein sequences\n",
+ "import os\n",
+ "os.environ['TF_FORCE_UNIFIED_MEMORY'] = '1'\n",
+ "os.environ['XLA_PYTHON_CLIENT_MEM_FRACTION'] = '2.0'\n",
+ "\n",
+ "from google.colab import files\n",
+ "import os.path\n",
+ "import re\n",
+ "\n",
+ "import hashlib\n",
+ "def add_hash(x,y):\n",
+ " return x+\"_\"+hashlib.sha1(y.encode()).hexdigest()[:5]\n",
+ "\n",
+ "query_sequence_a = 'AVLKIIQGALDTRELLKAYQEEACAKNFGAFCVFVGIVRKEDNIQGLSFDIYEALLKTWFEKWHHKAKDLGVVLKMAHSLGDVLIGQSSFLCVSMGKNRKNALELYENFIEDFKHNAPIWKYDLIHNKRIYAKERSHPLKGSGLLA' #@param {type:\"string\"}\n",
+ "query_sequence_a = \"\".join(query_sequence_a.split())\n",
+ "query_sequence_a = re.sub(r'[^A-Z]','', query_sequence_a.upper())\n",
+ "\n",
+ "query_sequence_b = 'MMVEVRFFGPIKEENFFIKANDLKELRAILQEKEGLKEWLGVCAIALNDHLIDNLNTPLKDGDVISLLPPVCGG' #@param {type:\"string\"}\n",
+ "query_sequence_b = \"\".join(query_sequence_b.split())\n",
+ "query_sequence_b = re.sub(r'[^A-Z]','', query_sequence_b.upper())\n",
+ "\n",
+ "# Using trick from @onoda_hiroki\n",
+ "# https://twitter.com/onoda_hiroki/status/1420068104239910915\n",
+ "# \"U\" indicates an \"UNKNOWN\" residue and it will not be modeled\n",
+ "# But we need linker of at least length 32\n",
+ "query_sequence_a = re.sub(r'U+',\"U\"*32,query_sequence_a)\n",
+ "query_sequence_b = re.sub(r'U+',\"U\"*32,query_sequence_b)\n",
+ "\n",
+ "query_sequence = query_sequence_a + query_sequence_b\n",
+ "\n",
+ "if len(query_sequence) > 1400:\n",
+ " print(f\"WARNING: For a typical Google-Colab-GPU (16G) session, the max total length is 1400 residues. You are at {len(query_sequence)}!\")\n",
+ "\n",
+ "jobname = 'test' #@param {type:\"string\"}\n",
+ "jobname = \"\".join(jobname.split())\n",
+ "jobname = re.sub(r'\\W+', '', jobname)\n",
+ "jobname = add_hash(jobname, query_sequence)\n",
+ "\n",
+ "# number of models to use\n",
+ "#@markdown ---\n",
+ "#@markdown ### Advanced settings\n",
+ "num_models = 5 #@param [1,2,3,4,5] {type:\"raw\"}\n",
+ "msa_mode = \"MMseqs2\" #@param [\"MMseqs2\",\"single_sequence\"]\n",
+ "use_msa = True if msa_mode == \"MMseqs2\" else False\n",
+ "pair_msa = False #@param {type:\"boolean\"}\n",
+ "disable_mmseqs2_filter = pair_msa\n",
+ "\n",
+ "#@markdown ---\n",
+ "with open(f\"{jobname}.log\", \"w\") as text_file:\n",
+ " text_file.write(\"num_models=%s\\n\" % num_models)\n",
+ " text_file.write(\"use_msa=%s\\n\" % use_msa)\n",
+ " text_file.write(\"msa_mode=%s\\n\" % msa_mode)\n",
+ " text_file.write(\"pair_msa=%s\\n\" % pair_msa)\n",
+ " text_file.write(\"disable_mmseqs2_filter=%s\\n\" % disable_mmseqs2_filter)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "iccGdbe_Pmt9",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Install dependencies\n",
+ "%%bash -s $use_msa\n",
+ "USE_MSA=$1\n",
+ "if [ ! -f AF2_READY ]; then\n",
+ "\n",
+ " # install dependencies\n",
+ " pip -q install biopython\n",
+ " pip -q install dm-haiku\n",
+ " pip -q install ml-collections\n",
+ " pip -q install py3Dmol\n",
+ "\n",
+ " wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\n",
+ "\n",
+ " # download model\n",
+ " if [ ! -d \"alphafold/\" ]; then\n",
+ " git clone https://github.com/deepmind/alphafold.git --quiet\n",
+ " mv alphafold alphafold_\n",
+ " mv alphafold_/alphafold .\n",
+ " # remove \"END\" from PDBs, otherwise biopython complains\n",
+ " sed -i \"s/pdb_lines.append('END')//\" /content/alphafold/common/protein.py\n",
+ " sed -i \"s/pdb_lines.append('ENDMDL')//\" /content/alphafold/common/protein.py\n",
+ " fi\n",
+ " # download model params (~1 min)\n",
+ " if [ ! -d \"params/\" ]; then\n",
+ " wget -qnc https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar\n",
+ " mkdir params\n",
+ " tar -xf alphafold_params_2021-07-14.tar -C params/\n",
+ " rm alphafold_params_2021-07-14.tar\n",
+ " fi\n",
+ " touch AF2_READY\n",
+ "fi"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "JPWfhGssZdTb",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Import libraries\n",
+ "# setup the model\n",
+ "if \"IMPORTED\" not in dir():\n",
+ "\n",
+ " import time\n",
+ " import requests\n",
+ " import tarfile\n",
+ " import sys\n",
+ " import numpy as np\n",
+ " import pickle\n",
+ "\n",
+ " from string import ascii_uppercase\n",
+ " from alphafold.common import protein\n",
+ " from alphafold.data import pipeline\n",
+ " from alphafold.data import templates\n",
+ " from alphafold.model import data\n",
+ " from alphafold.model import config\n",
+ " from alphafold.model import model\n",
+ " from alphafold.data.tools import hhsearch\n",
+ "\n",
+ " import colabfold as cf\n",
+ "\n",
+ " # plotting libraries\n",
+ " import py3Dmol\n",
+ " import matplotlib.pyplot as plt\n",
+ " IMPORTED = True\n",
+ "\n",
+ "def set_bfactor(pdb_filename, bfac, idx_res, chains):\n",
+ " I = open(pdb_filename,\"r\").readlines()\n",
+ " O = open(pdb_filename,\"w\")\n",
+ " for line in I:\n",
+ " if line[0:6] == \"ATOM \":\n",
+ " seq_id = int(line[22:26].strip()) - 1\n",
+ " seq_id = np.where(idx_res == seq_id)[0][0]\n",
+ " O.write(f\"{line[:21]}{chains[seq_id]}{line[22:60]}{bfac[seq_id]:6.2f}{line[66:]}\")\n",
+ " O.close()\n",
+ "\n",
+ "def predict_structure(prefix, feature_dict, Ls, random_seed=0, num_models=5): \n",
+ " \"\"\"Predicts structure using AlphaFold for the given sequence.\"\"\"\n",
+ " # Minkyung's code\n",
+ " # add big enough number to residue index to indicate chain breaks\n",
+ " idx_res = feature_dict['residue_index']\n",
+ " L_prev = 0\n",
+ " # Ls: number of residues in each chain\n",
+ " for L_i in Ls[:-1]:\n",
+ " idx_res[L_prev+L_i:] += 200\n",
+ " L_prev += L_i \n",
+ " chains = list(\"\".join([ascii_uppercase[n]*L for n,L in enumerate(Ls)]))\n",
+ " feature_dict['residue_index'] = idx_res\n",
+ "\n",
+ " # Run the models.\n",
+ " plddts = []\n",
+ " paes = []\n",
+ " unrelaxed_pdb_lines = []\n",
+ " relaxed_pdb_lines = []\n",
+ "\n",
+ " model_names = [\"model_4\",\"model_1\",\"model_2\",\"model_3\",\"model_5\"][:num_models]\n",
+ " for n,model_name in enumerate(model_names):\n",
+ " model_config = config.model_config(model_name+\"_ptm\")\n",
+ " model_config.data.eval.num_ensemble = 1\n",
+ " model_params = data.get_model_haiku_params(model_name+\"_ptm\", data_dir=\".\")\n",
+ "\n",
+ " if model_name == \"model_4\":\n",
+ " model_runner = model.RunModel(model_config, model_params)\n",
+ " processed_feature_dict = model_runner.process_features(feature_dict,random_seed=0)\n",
+ " else:\n",
+ " # swap params\n",
+ " for k in model_runner.params.keys():\n",
+ " model_runner.params[k] = model_params[k]\n",
+ "\n",
+ " print(f\"running model_{n+1}\")\n",
+ " prediction_result = model_runner.predict(processed_feature_dict)\n",
+ "\n",
+ " # cleanup to save memory\n",
+ " if model_name == \"model_5\": del model_runner\n",
+ " del model_params\n",
+ " \n",
+ " unrelaxed_protein = protein.from_prediction(processed_feature_dict,prediction_result)\n",
+ " unrelaxed_pdb_lines.append(protein.to_pdb(unrelaxed_protein))\n",
+ " plddts.append(prediction_result['plddt'])\n",
+ " paes.append(prediction_result['predicted_aligned_error'])\n",
+ "\n",
+ " # Delete unused outputs to save memory.\n",
+ " del prediction_result\n",
+ "\n",
+ " # rerank models based on predicted lddt\n",
+ " lddt_rank = np.mean(plddts,-1).argsort()[::-1]\n",
+ " plddts_ranked = {}\n",
+ " paes_ranked = {}\n",
+ " print(\"model\\tplldt\\tpae_ab\")\n",
+ " L = Ls[0]\n",
+ " for n,r in enumerate(lddt_rank):\n",
+ " plddt = plddts[r].mean()\n",
+ " pae_ab = (paes[r][L:,:L].mean() + paes[r][:L,L:].mean()) / 2\n",
+ " print(f\"model_{n+1}\\t{plddt:.2f}\\t{pae_ab:.2f}\")\n",
+ " \n",
+ " unrelaxed_pdb_path = f'{prefix}_unrelaxed_model_{n+1}.pdb' \n",
+ " with open(unrelaxed_pdb_path, 'w') as f:\n",
+ " f.write(unrelaxed_pdb_lines[r])\n",
+ " set_bfactor(unrelaxed_pdb_path, plddts[r], idx_res, chains)\n",
+ "\n",
+ " plddts_ranked[f\"model_{n+1}\"] = plddts[r]\n",
+ " paes_ranked[f\"model_{n+1}\"] = paes[r]\n",
+ "\n",
+ " return plddts_ranked, paes_ranked\n",
+ "\n",
+ "# CODE FROM MINKYUNG/ROSETTAFOLD\n",
+ "def read_a3m(a3m_lines):\n",
+ " '''parse an a3m files as a dictionary {label->sequence}'''\n",
+ " seq = []\n",
+ " lab = []\n",
+ " is_first = True\n",
+ " for line in a3m_lines.splitlines():\n",
+ " if line[0] == '>':\n",
+ " label = line.rstrip().split()[0][1:]\n",
+ " is_incl = True\n",
+ " if is_first: # include first sequence (query)\n",
+ " is_first = False\n",
+ " lab.append(label)\n",
+ " continue\n",
+ " if \"UniRef\" in label:\n",
+ " code = label.split()[0].split('_')[-1]\n",
+ " if code.startswith(\"UPI\"): # UniParc identifier -- exclude\n",
+ " is_incl = False\n",
+ " continue\n",
+ " elif label.startswith(\"tr|\"):\n",
+ " code = label.split('|')[1]\n",
+ " else:\n",
+ " is_incl = False\n",
+ " continue\n",
+ " lab.append(code)\n",
+ " else:\n",
+ " if is_incl:\n",
+ " seq.append(line.rstrip())\n",
+ " else:\n",
+ " continue\n",
+ " return seq, lab\n",
+ "\n",
+ "# https://www.uniprot.org/help/accession_numbers\n",
+ "def uni2idx(ids):\n",
+ " '''convert uniprot ids into integers according to the structure\n",
+ " of uniprot accession numbers'''\n",
+ " ids2 = [i.split(\"-\")[0] for i in ids]\n",
+ " ids2 = [i+'AAA0' if len(i)==6 else i for i in ids2]\n",
+ " arr = np.array([list(s) for s in ids2], dtype='|S1').view(np.uint8)\n",
+ " for i in [1,5,9]:\n",
+ " arr[:,i] -= ord('0')\n",
+ " arr[arr>=ord('A')] -= ord('A')\n",
+ " arr[arr>=ord('0')] -= ord('0')-26\n",
+ " arr[:,0][arr[:,0]>ord('Q')-ord('A')] -= 3\n",
+ " arr = arr.astype(np.int64)\n",
+ " coef = np.array([23,10,26,36,36,10,26,36,36,1], dtype=np.int64)\n",
+ " coef = np.tile(coef[None,:],[len(ids),1])\n",
+ " c1 = [i for i,id_ in enumerate(ids) if id_[0] in 'OPQ' and len(id_)==6]\n",
+ " c2 = [i for i,id_ in enumerate(ids) if id_[0] not in 'OPQ' and len(id_)==6]\n",
+ " coef[c1] = np.array([3, 10,36,36,36,1,1,1,1,1])\n",
+ " coef[c2] = np.array([23,10,26,36,36,1,1,1,1,1])\n",
+ " for i in range(1,10):\n",
+ " coef[:,-i-1] *= coef[:,-i]\n",
+ " return np.sum(arr*coef,axis=-1)\n",
+ "\n",
+ "def run_mmseqs2(query_sequence, prefix, use_env=True, filter=False):\n",
+ " def submit(query_sequence, mode):\n",
+ " res = requests.post('https://a3m.mmseqs.com/ticket/msa', data={'q':f\">1\\n{query_sequence}\", 'mode': mode})\n",
+ " return res.json()\n",
+ " def status(ID):\n",
+ " res = requests.get(f'https://a3m.mmseqs.com/ticket/{ID}')\n",
+ " return res.json()\n",
+ " def download(ID, path):\n",
+ " res = requests.get(f'https://a3m.mmseqs.com/result/download/{ID}')\n",
+ " with open(path,\"wb\") as out: out.write(res.content)\n",
+ " \n",
+ " if filter:\n",
+ " mode = \"env\" if use_env else \"all\"\n",
+ " else:\n",
+ " mode = \"env-nofilter\" if use_env else \"nofilter\"\n",
+ " \n",
+ " path = f\"{prefix}_{mode}\"\n",
+ " if not os.path.isdir(path): os.mkdir(path)\n",
+ "\n",
+ " # call mmseqs2 api\n",
+ " tar_gz_file = f'{path}/out.tar.gz'\n",
+ " if not os.path.isfile(tar_gz_file):\n",
+ " out = submit(query_sequence, mode)\n",
+ " while out[\"status\"] in [\"RUNNING\",\"PENDING\"]:\n",
+ " time.sleep(1)\n",
+ " out = status(out[\"id\"]) \n",
+ " download(out[\"id\"], tar_gz_file)\n",
+ " \n",
+ " # parse a3m files\n",
+ " a3m_lines = []\n",
+ " a3m = f\"{prefix}_{mode}.a3m\"\n",
+ " if not os.path.isfile(a3m):\n",
+ " with tarfile.open(tar_gz_file) as tar_gz: tar_gz.extractall(path)\n",
+ " a3m_files = [f\"{path}/uniref.a3m\"]\n",
+ " if use_env: a3m_files.append(f\"{path}/bfd.mgnify30.metaeuk30.smag30.a3m\")\n",
+ " a3m_out = open(a3m,\"w\")\n",
+ " for a3m_file in a3m_files:\n",
+ " for line in open(a3m_file,\"r\"):\n",
+ " line = line.replace(\"\\x00\",\"\")\n",
+ " if len(line) > 0:\n",
+ " a3m_lines.append(line)\n",
+ " a3m_out.write(line)\n",
+ " else:\n",
+ " a3m_lines = open(a3m).readlines()\n",
+ " return \"\".join(a3m_lines), len(a3m_lines)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "A9tUpDaikPC8",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Call MMseqs2 to get MSA for each gene \n",
+ "\n",
+ "Ls = [len(query_sequence_a),len(query_sequence_b)]\n",
+ "msas = []\n",
+ "deletion_matrices = []\n",
+ "if use_msa:\n",
+ " os.makedirs('tmp', exist_ok=True)\n",
+ " prefix = hashlib.sha1(query_sequence.encode()).hexdigest()\n",
+ " prefix = os.path.join('tmp',prefix)\n",
+ " print(f\"running mmseqs2 (use_env={True} filter={True})\")\n",
+ " a3m_lines = cf.run_mmseqs2([query_sequence_a, query_sequence_b], prefix, use_env=True, filter=True)\n",
+ " if pair_msa:\n",
+ " a3m_lines.append([])\n",
+ "\n",
+ " print(f\"running mmseqs2 for pair_msa (use_env={False} filter={False})\")\n",
+ " a3m_lines_pair = cf.run_mmseqs2([query_sequence_a, query_sequence_b], prefix, use_env=False, filter=False)\n",
+ "\n",
+ " # CODE FROM MINKYUNG/ROSETTAFOLD\n",
+ " msa1, lab1 = read_a3m(a3m_lines_pair[0])\n",
+ " msa2, lab2 = read_a3m(a3m_lines_pair[1])\n",
+ " if len(lab1) > 1 and len(lab2) > 1:\n",
+ " # convert uniprot ids into integers\n",
+ " hash1 = uni2idx(lab1[1:])\n",
+ " hash2 = uni2idx(lab2[1:])\n",
+ "\n",
+ " # find pairs of uniprot ids which are separated by at most 10\n",
+ " idx1, idx2 = np.where(np.abs(hash1[:,None]-hash2[None,:]) < 10)\n",
+ " if idx1.shape[0] > 0:\n",
+ " a3m_lines[2] = ['>query\\n%s%s\\n'%(msa1[0],msa2[0])]\n",
+ " for i,j in zip(idx1,idx2):\n",
+ " a3m_lines[2].append(\">%s_%s\\n%s%s\\n\"%(lab1[i+1],lab2[j+1],msa1[i+1],msa2[j+1]))\n",
+ " \n",
+ " msa, deletion_matrix = pipeline.parsers.parse_a3m(\"\".join(a3m_lines[2]))\n",
+ " msas.append(msa)\n",
+ " deletion_matrices.append(deletion_matrix)\n",
+ " print(\"pairs found:\",len(msa))\n",
+ " \n",
+ " msa, deletion_matrix = pipeline.parsers.parse_a3m(a3m_lines[0])\n",
+ " msas.append([seq+\"-\"*Ls[1] for seq in msa])\n",
+ " deletion_matrices.append([mtx+[0]*Ls[1] for mtx in deletion_matrix])\n",
+ "\n",
+ " msa, deletion_matrix = pipeline.parsers.parse_a3m(a3m_lines[1])\n",
+ " msas.append([\"-\"*Ls[0]+seq for seq in msa])\n",
+ " deletion_matrices.append([[0]*Ls[0]+mtx for mtx in deletion_matrix])\n",
+ "\n",
+ "else:\n",
+ " msas.append([query_sequence])\n",
+ " deletion_matrices.append([[0]*len(query_sequence)])\n",
+ "\n",
+ "feature_dict = {\n",
+ " **pipeline.make_sequence_features(sequence=query_sequence,\n",
+ " description=\"none\",\n",
+ " num_res=len(query_sequence)),\n",
+ " **pipeline.make_msa_features(msas=msas, deletion_matrices=deletion_matrices),\n",
+ "}"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "cellView": "form",
+ "id": "6sgAOSxCLIfC"
+ },
+ "source": [
+ "#@title Plot Number of Sequences per Position\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "# confidence per position\n",
+ "plt.figure(dpi=dpi)\n",
+ "plt.plot((feature_dict[\"msa\"] != 21).sum(0))\n",
+ "plt.xlabel(\"positions\")\n",
+ "plt.ylabel(\"number of sequences\")\n",
+ "plt.savefig(jobname+\"_msa_coverage.png\")\n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hUYApPElB30u",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Predict structure\n",
+ "plddts, paes = predict_structure(jobname, feature_dict, Ls=Ls, num_models=num_models)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "oCZxmXKKTAxt",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Plot Predicted Alignment Error\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "\n",
+ "# confidence per position\n",
+ "plt.figure(figsize=(3*num_models,2), dpi=dpi)\n",
+ "for n,(model_name,value) in enumerate(paes.items()):\n",
+ " plt.subplot(1,num_models,n+1)\n",
+ " plt.title(model_name)\n",
+ " plt.imshow(value,label=model_name,cmap=\"bwr\",vmin=0,vmax=30)\n",
+ " plt.colorbar()\n",
+ "plt.savefig(jobname+\"_PAE.png\")\n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "exKwNxDxF7IO",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Plot lDDT per residue\n",
+ "# confidence per position\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "plt.figure(dpi=dpi)\n",
+ "for model_name,value in plddts.items():\n",
+ " plt.plot(value,label=model_name)\n",
+ "plt.legend()\n",
+ "plt.ylim(0,100)\n",
+ "plt.ylabel(\"predicted lDDT\")\n",
+ "plt.xlabel(\"positions\")\n",
+ "plt.savefig(jobname+\"_lDDT.png\")\n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "g-rPnOXdjf18",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "model_num = 1 #@param [\"1\", \"2\", \"3\", \"4\", \"5\"] {type:\"raw\"}\n",
+ "color = \"chain\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "def plot_plddt_legend():\n",
+ " thresh = ['plDDT:','Very low (<50)','Low (60)','OK (70)','Confident (80)','Very high (>90)']\n",
+ " plt.figure(figsize=(1,0.1),dpi=100)\n",
+ " ########################################\n",
+ " for c in [\"#FFFFFF\",\"#FF0000\",\"#FFFF00\",\"#00FF00\",\"#00FFFF\",\"#0000FF\"]:\n",
+ " plt.bar(0, 0, color=c)\n",
+ " plt.legend(thresh, frameon=False,\n",
+ " loc='center', ncol=6,\n",
+ " handletextpad=1,\n",
+ " columnspacing=1,\n",
+ " markerscale=0.5,)\n",
+ " plt.axis(False)\n",
+ " return plt\n",
+ "\n",
+ "def plot_confidence(model_num=1):\n",
+ " model_name = f\"model_{model_num}\"\n",
+ " plt.figure(figsize=(10,3),dpi=100)\n",
+ " \"\"\"Plots the legend for plDDT.\"\"\"\n",
+ " #########################################\n",
+ " plt.subplot(1,2,1); plt.title('Predicted lDDT')\n",
+ " plt.plot(plddts[model_name])\n",
+ " for x in [len(query_sequence_a)]:\n",
+ " plt.plot([x,x],[0,100],color=\"black\")\n",
+ "\n",
+ " plt.ylabel('plDDT')\n",
+ " plt.xlabel('position')\n",
+ " #########################################\n",
+ " plt.subplot(1,2,2);plt.title('Predicted Aligned Error')\n",
+ " plt.imshow(paes[model_name], cmap=\"bwr\",vmin=0,vmax=30)\n",
+ " plt.colorbar()\n",
+ " plt.xlabel('Scored residue')\n",
+ " plt.ylabel('Aligned residue')\n",
+ " #########################################\n",
+ " return plt\n",
+ "\n",
+ "def show_pdb(model_num=1, show_sidechains=False, show_mainchains=False, color=\"lDDT\"):\n",
+ " model_name = f\"model_{model_num}\"\n",
+ " pdb_filename = f\"{jobname}_unrelaxed_{model_name}.pdb\"\n",
+ "\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
+ " view.addModel(open(pdb_filename,'r').read(),'pdb')\n",
+ "\n",
+ " if color == \"lDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':50,'max':90}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(2),list(\"ABCDEFGH\"),\n",
+ " [\"lime\",\"cyan\",\"magenta\",\"yellow\",\"salmon\",\"white\",\"blue\",\"orange\"]):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}}) \n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ "\n",
+ " view.zoomTo()\n",
+ " return view\n",
+ "\n",
+ "show_pdb(model_num,show_sidechains, show_mainchains, color).show()\n",
+ "if color == \"lDDT\": plot_plddt_legend().show() \n",
+ "plot_confidence(model_num).show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "33g5IIegij5R",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Package and download results\n",
+ "!zip -FSr $jobname\".result.zip\" $jobname\".log\" $jobname\"_msa_coverage.png\" $jobname\"_\"*\"relaxed_model_\"*\".pdb\" $jobname\"_lDDT.png\" $jobname\"_PAE.png\"\n",
+ "files.download(f\"{jobname}.result.zip\")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vP1m6jI7BgMT"
+ },
+ "source": [
+ "# Instructions\n",
+ "- If you having issues downloading results, try disable adblocker and run the last cell again. If that fails click on the little folder icon to the left, navigate to file:`jobname.result.zip`, right-click and select \"download\".\n",
+ "\n",
+ "\n",
+ "# License\n",
+ "\n",
+ "The source code of ColabFold is licensed under [MIT](https://raw.githubusercontent.com/sokrypton/ColabFold/main/LICENSE). Additionally, this notebook uses AlphaFold2 source code and its parameters licensed under [Apache 2.0](https://raw.githubusercontent.com/deepmind/alphafold/main/LICENSE) and [CC BY 4.0](https://creativecommons.org/licenses/by-sa/4.0/) respectively. Read more about the AlphaFold license [here](https://github.com/deepmind/alphafold)."
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/AlphaFold_wJackhmmer.ipynb b/data/beta/AlphaFold_wJackhmmer.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3271e0bcfaaff32115bf2ffbb915f48062d0c9bf
--- /dev/null
+++ b/data/beta/AlphaFold_wJackhmmer.ipynb
@@ -0,0 +1,793 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "name": "AlphaFold_wJackhmmer.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pc5-mbsX9PZC"
+ },
+ "source": [
+ "# AlphaFold2 w/ Jackhmmer (or MMseqs2)\n",
+ "\n",
+ "---------\n",
+ "**UPDATE** (Aug. 13, 2021)\n",
+ "\n",
+ "This notebook is being retired and no longer updated. The functionality to search using jackhmmer/mmseqs has been integrated in our [new advanced notebook](https://github.com/sokrypton/ColabFold/blob/main/beta/AlphaFold2_advanced.ipynb).\n",
+ "\n",
+ "---------\n",
+ "\n",
+ "This notebook modifies deepmind's [original notebook](https://colab.research.google.com/github/deepmind/alphafold/blob/main/notebooks/AlphaFold.ipynb) to add experimental homooligomer support and option to run MMseqs2 instead of Jackhmmer for MSA generation.\n",
+ "\n",
+ "See [ColabFold](https://github.com/sokrypton/ColabFold/) for other related notebooks\n",
+ "\n",
+ "**Limitations**\n",
+ "- This notebook does NOT use Templates.\n",
+ "- For a typical Google-Colab-GPU (16G) session, the max total length is **1400 residues**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "woIxeCPygt7K",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Install software\n",
+ "#@markdown Please execute this cell by pressing the _Play_ button \n",
+ "#@markdown on the left.\n",
+ "use_amber_relax = True #@param {type:\"boolean\"}\n",
+ "\n",
+ "import os\n",
+ "os.environ['TF_FORCE_UNIFIED_MEMORY'] = '1'\n",
+ "os.environ['XLA_PYTHON_CLIENT_MEM_FRACTION'] = '2.0'\n",
+ "\n",
+ "from IPython.utils import io\n",
+ "import subprocess\n",
+ "import requests\n",
+ "import hashlib\n",
+ "import tarfile\n",
+ "import time\n",
+ "import tqdm.notebook\n",
+ "\n",
+ "from sys import version_info \n",
+ "python_version = f\"{version_info.major}.{version_info.minor}\"\n",
+ "\n",
+ "GIT_REPO = 'https://github.com/deepmind/alphafold'\n",
+ "SOURCE_URL = 'https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar'\n",
+ "PARAMS_DIR = './alphafold/data/params'\n",
+ "PARAMS_PATH = os.path.join(PARAMS_DIR, os.path.basename(SOURCE_URL))\n",
+ "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
+ "\n",
+ "# if not already installed\n",
+ "if not os.path.isdir(\"alphafold\"):\n",
+ " try:\n",
+ " total = 100 if use_amber_relax else 55\n",
+ " with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " with io.capture_output() as captured:\n",
+ " #######################################################################\n",
+ " %shell rm -rf alphafold\n",
+ " %shell git clone {GIT_REPO} alphafold\n",
+ "\n",
+ " # Apply multi-chain patch from Lim Heo @huhlim\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/protein.patch\n",
+ " %shell (patch -u alphafold/alphafold/common/protein.py -i /content/protein.patch)\n",
+ "\n",
+ " pbar.update(4)\n",
+ " %shell pip3 install ./alphafold\n",
+ " pbar.update(5)\n",
+ " \n",
+ " %shell mkdir --parents \"{PARAMS_DIR}\"\n",
+ " %shell wget -O \"{PARAMS_PATH}\" \"{SOURCE_URL}\"\n",
+ " pbar.update(14)\n",
+ "\n",
+ " %shell tar --extract --verbose --file=\"{PARAMS_PATH}\" \\\n",
+ " --directory=\"{PARAMS_DIR}\" --preserve-permissions\n",
+ " %shell rm \"{PARAMS_PATH}\"\n",
+ " pbar.update(27)\n",
+ "\n",
+ " #######################################################################\n",
+ " %shell sudo apt install --quiet --yes hmmer\n",
+ " pbar.update(3)\n",
+ "\n",
+ " # Install py3dmol.\n",
+ " %shell pip install py3dmol\n",
+ " pbar.update(1)\n",
+ "\n",
+ " if use_amber_relax:\n",
+ " # Install OpenMM and pdbfixer.\n",
+ " %shell rm -rf /opt/conda\n",
+ " %shell wget -q -P /tmp \\\n",
+ " https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \\\n",
+ " && bash /tmp/Miniconda3-latest-Linux-x86_64.sh -b -p /opt/conda \\\n",
+ " && rm /tmp/Miniconda3-latest-Linux-x86_64.sh\n",
+ " pbar.update(4)\n",
+ "\n",
+ " PATH=%env PATH\n",
+ " %env PATH=/opt/conda/bin:{PATH}\n",
+ " %shell conda update -qy conda \\\n",
+ " && conda install -qy -c conda-forge \\\n",
+ " python={python_version} \\\n",
+ " openmm=7.5.1 \\\n",
+ " pdbfixer\n",
+ " pbar.update(40)\n",
+ "\n",
+ " %shell wget -q -P /content \\\n",
+ " https://git.scicore.unibas.ch/schwede/openstructure/-/raw/7102c63615b64735c4941278d92b554ec94415f8/modules/mol/alg/src/stereo_chemical_props.txt\n",
+ " pbar.update(1)\n",
+ " %shell mkdir -p /content/alphafold/common\n",
+ " %shell cp -f /content/stereo_chemical_props.txt /content/alphafold/common\n",
+ "\n",
+ " # Apply OpenMM patch.\n",
+ " %shell pushd /opt/conda/lib/python{python_version}/site-packages/ && \\\n",
+ " patch -p0 < /content/alphafold/docker/openmm.patch && \\\n",
+ " popd\n",
+ "\n",
+ " # Create a ramdisk to store a database chunk to make Jackhmmer run fast.\n",
+ " %shell sudo mkdir -m 777 --parents /tmp/ramdisk\n",
+ " %shell sudo mount -t tmpfs -o size=9G ramdisk /tmp/ramdisk\n",
+ " pbar.update(1)\n",
+ "\n",
+ " except subprocess.CalledProcessError:\n",
+ " print(captured)\n",
+ " raise\n",
+ "\n",
+ " ########################################################################################\n",
+ " ########################################################################################\n",
+ "\n",
+ "import jax\n",
+ "if jax.local_devices()[0].platform == 'tpu':\n",
+ " raise RuntimeError('Colab TPU runtime not supported. Change it to GPU via Runtime -> Change Runtime Type -> Hardware accelerator -> GPU.')\n",
+ "elif jax.local_devices()[0].platform == 'cpu':\n",
+ " raise RuntimeError('Colab CPU runtime not supported. Change it to GPU via Runtime -> Change Runtime Type -> Hardware accelerator -> GPU.')\n",
+ "\n",
+ "# --- Python imports ---\n",
+ "import sys\n",
+ "import pickle\n",
+ "if use_amber_relax:\n",
+ " sys.path.append(f\"/opt/conda/lib/python{python_version}/site-packages\")\n",
+ "\n",
+ "from urllib import request\n",
+ "from concurrent import futures\n",
+ "from google.colab import files\n",
+ "import json\n",
+ "from matplotlib import gridspec\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import py3Dmol\n",
+ "\n",
+ "from alphafold.model import model\n",
+ "from alphafold.model import config\n",
+ "from alphafold.model import data\n",
+ "\n",
+ "from alphafold.data import parsers\n",
+ "from alphafold.data import pipeline\n",
+ "from alphafold.data.tools import jackhmmer\n",
+ "\n",
+ "from alphafold.common import protein\n",
+ "\n",
+ "if use_amber_relax:\n",
+ " from alphafold.relax import relax\n",
+ " from alphafold.relax import utils\n",
+ "\n",
+ "#######################################################################################\n",
+ "#######################################################################################\n",
+ "def run_mmseqs2(query_sequence, prefix, use_env=True, filter=False):\n",
+ " def submit(query_sequence, mode):\n",
+ " res = requests.post('https://a3m.mmseqs.com/ticket/msa', data={'q':f\">1\\n{query_sequence}\", 'mode': mode})\n",
+ " return res.json()\n",
+ " def status(ID):\n",
+ " res = requests.get(f'https://a3m.mmseqs.com/ticket/{ID}')\n",
+ " return res.json()\n",
+ " def download(ID, path):\n",
+ " res = requests.get(f'https://a3m.mmseqs.com/result/download/{ID}')\n",
+ " with open(path,\"wb\") as out: out.write(res.content)\n",
+ " \n",
+ " if filter:\n",
+ " mode = \"env\" if use_env else \"all\"\n",
+ " else:\n",
+ " mode = \"env-nofilter\" if use_env else \"nofilter\"\n",
+ " \n",
+ " path = f\"{prefix}_{mode}\"\n",
+ " if not os.path.isdir(path): os.mkdir(path)\n",
+ "\n",
+ " # call mmseqs2 api\n",
+ " tar_gz_file = f'{path}/out.tar.gz'\n",
+ " if not os.path.isfile(tar_gz_file):\n",
+ " out = submit(query_sequence, mode)\n",
+ " while out[\"status\"] in [\"RUNNING\",\"PENDING\"]:\n",
+ " time.sleep(1)\n",
+ " out = status(out[\"id\"]) \n",
+ " download(out[\"id\"], tar_gz_file)\n",
+ " \n",
+ " # parse a3m files\n",
+ " a3m_lines = []\n",
+ " a3m = f\"{prefix}_{mode}.a3m\"\n",
+ " if not os.path.isfile(a3m):\n",
+ " with tarfile.open(tar_gz_file) as tar_gz: tar_gz.extractall(path)\n",
+ " a3m_files = [f\"{path}/uniref.a3m\"]\n",
+ " if use_env: a3m_files.append(f\"{path}/bfd.mgnify30.metaeuk30.smag30.a3m\")\n",
+ " a3m_out = open(a3m,\"w\")\n",
+ " for a3m_file in a3m_files:\n",
+ " for line in open(a3m_file,\"r\"):\n",
+ " line = line.replace(\"\\x00\",\"\")\n",
+ " if len(line) > 0:\n",
+ " a3m_lines.append(line)\n",
+ " a3m_out.write(line)\n",
+ " else:\n",
+ " a3m_lines = open(a3m).readlines()\n",
+ " return \"\".join(a3m_lines)\n",
+ "\n",
+ "def run_jackhmmer(sequence, prefix):\n",
+ " pickled_msa_path = f\"{prefix}.jackhmmer.pickle\"\n",
+ " if os.path.isfile(pickled_msa_path):\n",
+ " msas_dict = pickle.load(open(pickled_msa_path,\"rb\"))\n",
+ " msas, deletion_matrices = (msas_dict[k] for k in ['msas', 'deletion_matrices'])\n",
+ " full_msa = []\n",
+ " for msa in msas:\n",
+ " full_msa += msa\n",
+ " else:\n",
+ " # --- Find the closest source ---\n",
+ " test_url_pattern = 'https://storage.googleapis.com/alphafold-colab{:s}/latest/uniref90_2021_03.fasta.1'\n",
+ " ex = futures.ThreadPoolExecutor(3)\n",
+ " def fetch(source):\n",
+ " request.urlretrieve(test_url_pattern.format(source))\n",
+ " return source\n",
+ " fs = [ex.submit(fetch, source) for source in ['', '-europe', '-asia']]\n",
+ " source = None\n",
+ " for f in futures.as_completed(fs):\n",
+ " source = f.result()\n",
+ " ex.shutdown()\n",
+ " break\n",
+ "\n",
+ " jackhmmer_binary_path = '/usr/bin/jackhmmer'\n",
+ " dbs = []\n",
+ "\n",
+ " num_jackhmmer_chunks = {'uniref90': 59, 'smallbfd': 17, 'mgnify': 71}\n",
+ " total_jackhmmer_chunks = sum(num_jackhmmer_chunks.values())\n",
+ " with tqdm.notebook.tqdm(total=total_jackhmmer_chunks, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " def jackhmmer_chunk_callback(i):\n",
+ " pbar.update(n=1)\n",
+ "\n",
+ " pbar.set_description('Searching uniref90')\n",
+ " jackhmmer_uniref90_runner = jackhmmer.Jackhmmer(\n",
+ " binary_path=jackhmmer_binary_path,\n",
+ " database_path=f'https://storage.googleapis.com/alphafold-colab{source}/latest/uniref90_2021_03.fasta',\n",
+ " get_tblout=True,\n",
+ " num_streamed_chunks=num_jackhmmer_chunks['uniref90'],\n",
+ " streaming_callback=jackhmmer_chunk_callback,\n",
+ " z_value=135301051)\n",
+ " dbs.append(('uniref90', jackhmmer_uniref90_runner.query('target.fasta')))\n",
+ "\n",
+ " pbar.set_description('Searching smallbfd')\n",
+ " jackhmmer_smallbfd_runner = jackhmmer.Jackhmmer(\n",
+ " binary_path=jackhmmer_binary_path,\n",
+ " database_path=f'https://storage.googleapis.com/alphafold-colab{source}/latest/bfd-first_non_consensus_sequences.fasta',\n",
+ " get_tblout=True,\n",
+ " num_streamed_chunks=num_jackhmmer_chunks['smallbfd'],\n",
+ " streaming_callback=jackhmmer_chunk_callback,\n",
+ " z_value=65984053)\n",
+ " dbs.append(('smallbfd', jackhmmer_smallbfd_runner.query('target.fasta')))\n",
+ "\n",
+ " pbar.set_description('Searching mgnify')\n",
+ " jackhmmer_mgnify_runner = jackhmmer.Jackhmmer(\n",
+ " binary_path=jackhmmer_binary_path,\n",
+ " database_path=f'https://storage.googleapis.com/alphafold-colab{source}/latest/mgy_clusters_2019_05.fasta',\n",
+ " get_tblout=True,\n",
+ " num_streamed_chunks=num_jackhmmer_chunks['mgnify'],\n",
+ " streaming_callback=jackhmmer_chunk_callback,\n",
+ " z_value=304820129)\n",
+ " dbs.append(('mgnify', jackhmmer_mgnify_runner.query('target.fasta')))\n",
+ "\n",
+ " # --- Extract the MSAs and visualize ---\n",
+ " # Extract the MSAs from the Stockholm files.\n",
+ " # NB: deduplication happens later in pipeline.make_msa_features.\n",
+ "\n",
+ " mgnify_max_hits = 501\n",
+ " msas = []\n",
+ " deletion_matrices = []\n",
+ " for db_name, db_results in dbs:\n",
+ " unsorted_results = []\n",
+ " for i, result in enumerate(db_results):\n",
+ " msa, deletion_matrix, target_names = parsers.parse_stockholm(result['sto'])\n",
+ " e_values_dict = parsers.parse_e_values_from_tblout(result['tbl'])\n",
+ " e_values = [e_values_dict[t.split('/')[0]] for t in target_names]\n",
+ " zipped_results = zip(msa, deletion_matrix, target_names, e_values)\n",
+ " if i != 0:\n",
+ " # Only take query from the first chunk\n",
+ " zipped_results = [x for x in zipped_results if x[2] != 'query']\n",
+ " unsorted_results.extend(zipped_results)\n",
+ " sorted_by_evalue = sorted(unsorted_results, key=lambda x: x[3])\n",
+ " db_msas, db_deletion_matrices, _, _ = zip(*sorted_by_evalue)\n",
+ " if db_msas:\n",
+ " if db_name == 'mgnify':\n",
+ " db_msas = db_msas[:mgnify_max_hits]\n",
+ " db_deletion_matrices = db_deletion_matrices[:mgnify_max_hits]\n",
+ " msas.append(db_msas)\n",
+ " deletion_matrices.append(db_deletion_matrices)\n",
+ " msa_size = len(set(db_msas))\n",
+ " print(f'{msa_size} Sequences Found in {db_name}')\n",
+ "\n",
+ " pickle.dump({\"msas\":msas,\"deletion_matrices\":deletion_matrices},\n",
+ " open(pickled_msa_path,\"wb\"))\n",
+ " return msas, deletion_matrices"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "W4JpOs6oA-QS"
+ },
+ "source": [
+ "## Making a prediction\n",
+ "\n",
+ "Please paste the sequence of your protein in the text box below, then run the remaining cells via _Runtime_ > _Run after_. You can also run the cells individually by pressing the _Play_ button on the left.\n",
+ "\n",
+ "Note that the search against databases and the actual prediction can take some time, from minutes to hours, depending on the length of the protein and what type of GPU you are allocated by Colab (see FAQ below)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "rowN0bVYLe9n",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Enter the amino acid sequence to fold ⬇️\n",
+ "sequence = 'PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK' #@param {type:\"string\"}\n",
+ "\n",
+ "MIN_SEQUENCE_LENGTH = 16\n",
+ "MAX_SEQUENCE_LENGTH = 2500\n",
+ "\n",
+ "# Remove all whitespaces, tabs and end lines; upper-case\n",
+ "sequence = sequence.translate(str.maketrans('', '', ' \\n\\t')).upper()\n",
+ "#@markdown ### Experimental options\n",
+ "homooligomer = 1 #@param [1,2,3,4,5,6,7,8] {type:\"raw\"}\n",
+ "\n",
+ "full_sequence = sequence * homooligomer\n",
+ "\n",
+ "aatypes = set('ACDEFGHIKLMNPQRSTVWY') # 20 standard aatypes\n",
+ "if not set(sequence).issubset(aatypes):\n",
+ " raise Exception(f'Input sequence contains non-amino acid letters: {set(sequence) - aatypes}. AlphaFold only supports 20 standard amino acids as inputs.')\n",
+ "if len(full_sequence) < MIN_SEQUENCE_LENGTH:\n",
+ " raise Exception(f'Input sequence is too short: {len(full_sequence)} amino acids, while the minimum is {MIN_SEQUENCE_LENGTH}')\n",
+ "if len(full_sequence) > MAX_SEQUENCE_LENGTH:\n",
+ " raise Exception(f'Input sequence is too long: {len(full_sequence)} amino acids, while the maximum is {MAX_SEQUENCE_LENGTH}. Please use the full AlphaFold system for long sequences.')\n",
+ "\n",
+ "if len(full_sequence) > 1400:\n",
+ " print(f\"WARNING: For a typical Google-Colab-GPU (16G) session, the max total length is 1400 residues. You are at {len(full_sequence)}!\")"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Zq5EC6ju-XPo",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Search against genetic databases\n",
+ "#@markdown Once this cell has been executed, you will see\n",
+ "#@markdown statistics about the multiple sequence alignment \n",
+ "#@markdown (MSA) that will be used by AlphaFold. In particular, \n",
+ "#@markdown you’ll see how well each residue is covered by similar \n",
+ "#@markdown sequences in the MSA.\n",
+ "\n",
+ "#@markdown ---\n",
+ "msa_method = \"jackhmmer\" #@param [\"jackhmmer\",\"mmseqs2\",\"single_sequence\",\"custom_a3m\",\"precomputed\"]\n",
+ "#@markdown - `jackhmmer` - default approach from Deepmind\n",
+ "#@markdown - `mmseqs2` - fast method from [ColabFold](https://github.com/sokrypton/ColabFold)\n",
+ "#@markdown - `single_sequence` - use single sequence input (not recommended, unless a *denovo* design and you dont expect to find any homologous sequences)\n",
+ "#@markdown - `custom_a3m` Upload custom MSA (a3m format)\n",
+ "#@markdown - `precomputed` If you have previously run this notebook and saved the results,\n",
+ "#@markdown you can skip this step by uploading \n",
+ "#@markdown the previously generated `prediction/msa.npz`\n",
+ "\n",
+ "# prediction directory\n",
+ "output_dir = 'prediction'\n",
+ "os.makedirs(output_dir, exist_ok=True)\n",
+ "\n",
+ "# tmp directory\n",
+ "prefix = hashlib.sha1(sequence.encode()).hexdigest()\n",
+ "os.makedirs('tmp', exist_ok=True)\n",
+ "prefix = os.path.join('tmp',prefix)\n",
+ "\n",
+ "# --- Search against genetic databases ---\n",
+ "with open('target.fasta', 'wt') as f:\n",
+ " f.write(f'>query\\n{sequence}')\n",
+ "\n",
+ "# Run the search against chunks of genetic databases (since the genetic\n",
+ "# databases don't fit in Colab ramdisk).\n",
+ "\n",
+ "if msa_method == \"precomputed\":\n",
+ " print(\"upload precomputed pickled msa from previous run\")\n",
+ " pickled_msa_dict = files.upload()\n",
+ " msas_dict = pickle.loads(pickled_msa_dict[list(pickled_msa_dict.keys())[0]])\n",
+ " msas, deletion_matrices = (msas_dict[k] for k in ['msas', 'deletion_matrices'])\n",
+ "\n",
+ "elif msa_method == \"mmseqs2\":\n",
+ " msa, deletion_matrix = parsers.parse_a3m(run_mmseqs2(sequence, prefix, filter=True))\n",
+ " msas,deletion_matrices = [msa],[deletion_matrix]\n",
+ "\n",
+ "elif msa_method == \"single_sequence\":\n",
+ " msas = [[sequence]]\n",
+ " deletion_matrices = [[[0]*len(sequence)]]\n",
+ "\n",
+ "elif msa_method == \"custom_a3m\":\n",
+ " print(\"upload custom a3m\")\n",
+ " msa_dict = files.upload()\n",
+ " lines = msa_dict[list(msa_dict.keys())[0]].decode().splitlines()\n",
+ " a3m_lines = []\n",
+ " for line in lines:\n",
+ " line = line.replace(\"\\x00\",\"\")\n",
+ " if len(line) > 0 and not line.startswith('#'):\n",
+ " a3m_lines.append(line)\n",
+ " msa, deletion_matrix = parsers.parse_a3m(\"\\n\".join(a3m_lines))\n",
+ " msas,deletion_matrices = [msa],[deletion_matrix]\n",
+ "\n",
+ " if len(msas[0][0]) != len(sequence):\n",
+ " print(\"ERROR: the length of msa does not match input sequence\")\n",
+ "\n",
+ "else:\n",
+ " # run jackhmmer\n",
+ " msas, deletion_matrices = run_jackhmmer(sequence, prefix)\n",
+ "\n",
+ "full_msa = []\n",
+ "for msa in msas: full_msa += msa\n",
+ "\n",
+ "# save MSA as pickle\n",
+ "pickle.dump({\"msas\":msas,\"deletion_matrices\":deletion_matrices},\n",
+ " open(\"prediction/msa.pickle\",\"wb\"))\n",
+ "\n",
+ "# deduplicate\n",
+ "deduped_full_msa = list(dict.fromkeys(full_msa))\n",
+ "total_msa_size = len(deduped_full_msa)\n",
+ "print(f'\\n{total_msa_size} Sequences Found in Total\\n')\n",
+ "\n",
+ "msa_arr = np.array([list(seq) for seq in deduped_full_msa])\n",
+ "num_alignments, num_res = msa_arr.shape\n",
+ "\n",
+ "plt.figure(figsize=(8,5),dpi=100)\n",
+ "plt.title(\"Sequence coverage\")\n",
+ "seqid = (np.array(list(sequence)) == msa_arr).mean(-1)\n",
+ "seqid_sort = seqid.argsort() #[::-1]\n",
+ "non_gaps = (msa_arr != \"-\").astype(float)\n",
+ "non_gaps[non_gaps == 0] = np.nan\n",
+ "plt.imshow(non_gaps[seqid_sort]*seqid[seqid_sort,None],\n",
+ " interpolation='nearest', aspect='auto',\n",
+ " cmap=\"rainbow_r\", vmin=0, vmax=1, origin='lower')\n",
+ "plt.plot((msa_arr != \"-\").sum(0), color='black')\n",
+ "plt.xlim(-0.5,msa_arr.shape[1]-0.5)\n",
+ "plt.ylim(-0.5,msa_arr.shape[0]-0.5)\n",
+ "plt.colorbar(label=\"Sequence identity to query\",)\n",
+ "plt.xlabel(\"Positions\")\n",
+ "plt.ylabel(\"Sequences\")\n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "DynHMYHTzXbO",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Run AlphaFold \n",
+ "\n",
+ "#@markdown ---\n",
+ "relax_all = False #@param {type:\"boolean\"}\n",
+ "turbo = False #@param {type:\"boolean\"}\n",
+ "#@markdown - `relax_all` If disabled, only top ranked model is amber-relaxed.\n",
+ "#@markdown - `turbo` mode compiles a single model then swaps out params to speedup calculation. Warning, this option is experimental, and not extensively tested.\n",
+ "\n",
+ "\n",
+ "# --- Run the model ---\n",
+ "from string import ascii_uppercase\n",
+ "\n",
+ "def _placeholder_template_feats(num_templates_, num_res_):\n",
+ " return {\n",
+ " 'template_aatype': np.zeros([num_templates_, num_res_, 22], np.float32),\n",
+ " 'template_all_atom_masks': np.zeros([num_templates_, num_res_, 37, 3], np.float32),\n",
+ " 'template_all_atom_positions': np.zeros([num_templates_, num_res_, 37], np.float32),\n",
+ " 'template_domain_names': np.zeros([num_templates_], np.float32),\n",
+ " 'template_sum_probs': np.zeros([num_templates_], np.float32),\n",
+ " }\n",
+ "\n",
+ "num_templates = 0\n",
+ "num_res = len(sequence)\n",
+ "\n",
+ "if homooligomer == 1:\n",
+ " msas_mod = msas\n",
+ " deletion_matrices_mod = deletion_matrices\n",
+ "else:\n",
+ " msas_mod = []\n",
+ " deletion_matrices_mod = []\n",
+ " for o in range(homooligomer):\n",
+ " L = num_res * o\n",
+ " R = num_res * (homooligomer-(o+1))\n",
+ " for msa,deletion_matrix in zip(msas,deletion_matrices):\n",
+ " msas_mod.append([\"-\"*L+seq+\"-\"*R for seq in msa])\n",
+ " deletion_matrices_mod.append([[0]*L+mtx+[0]*R for mtx in deletion_matrix])\n",
+ "\n",
+ "\n",
+ "feature_dict = {}\n",
+ "feature_dict.update(pipeline.make_sequence_features(sequence*homooligomer, 'test', num_res*homooligomer))\n",
+ "feature_dict.update(pipeline.make_msa_features(msas_mod, deletion_matrices=deletion_matrices_mod))\n",
+ "feature_dict.update(_placeholder_template_feats(num_templates, num_res*homooligomer))\n",
+ "\n",
+ "# Minkyung's code\n",
+ "# add big enough number to residue index to indicate chain breaks\n",
+ "idx_res = feature_dict['residue_index']\n",
+ "L_prev = 0\n",
+ "Ls = [num_res]*homooligomer\n",
+ "for L_i in Ls[:-1]:\n",
+ " idx_res[L_prev+L_i:] += 200\n",
+ " L_prev += L_i \n",
+ "feature_dict['residue_index'] = idx_res\n",
+ "\n",
+ "plddts = {}\n",
+ "pae_outputs = {}\n",
+ "unrelaxed_proteins = {}\n",
+ "\n",
+ "model_names = ['model_4', 'model_1', 'model_2', 'model_3', 'model_5']\n",
+ "\n",
+ "total = len(model_names)\n",
+ "if use_amber_relax:\n",
+ " if relax_all: total += total\n",
+ " else: total += 1\n",
+ "\n",
+ "with tqdm.notebook.tqdm(total=total, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " for num,model_name in enumerate(model_names):\n",
+ " pbar.set_description(f'Running model_{num+1}')\n",
+ "\n",
+ " cfg = config.model_config(model_name+\"_ptm\")\n",
+ " params = data.get_model_haiku_params(model_name+\"_ptm\", './alphafold/data')\n",
+ " if turbo:\n",
+ " #####################################################\n",
+ " # load models or params\n",
+ " if model_name == \"model_4\":\n",
+ " # define model and process features\n",
+ " model_runner = model.RunModel(cfg, params)\n",
+ " processed_feature_dict = model_runner.process_features(feature_dict,random_seed=0)\n",
+ " else:\n",
+ " # swap params\n",
+ " for k in model_runner.params.keys():\n",
+ " model_runner.params[k] = params[k]\n",
+ " prediction_result = model_runner.predict(processed_feature_dict) \n",
+ " # cleanup to save memory\n",
+ " if model_name == \"model_5\": del model_runner\n",
+ " del params\n",
+ " #####################################################\n",
+ " else:\n",
+ " #####################################################\n",
+ " model_runner = model.RunModel(cfg, params)\n",
+ "\n",
+ " processed_feature_dict = model_runner.process_features(feature_dict,random_seed=0)\n",
+ " prediction_result = model_runner.predict(processed_feature_dict) \n",
+ "\n",
+ " # cleanup to save memory\n",
+ " del params\n",
+ " del model_runner\n",
+ " #####################################################\n",
+ "\n",
+ " mean_plddt = prediction_result['plddt'].mean()\n",
+ "\n",
+ " # Get the pLDDT confidence metrics.\n",
+ " pae_outputs[model_name] = (\n",
+ " prediction_result['predicted_aligned_error'],\n",
+ " prediction_result['max_predicted_aligned_error']\n",
+ " )\n",
+ " plddts[model_name] = prediction_result['plddt']\n",
+ "\n",
+ " # Set the b-factors to the per-residue plddt.\n",
+ " final_atom_mask = prediction_result['structure_module']['final_atom_mask']\n",
+ " b_factors = prediction_result['plddt'][:, None] * final_atom_mask\n",
+ " unrelaxed_protein = protein.from_prediction(processed_feature_dict,\n",
+ " prediction_result,\n",
+ " b_factors=b_factors)\n",
+ " unrelaxed_proteins[model_name] = unrelaxed_protein\n",
+ "\n",
+ " # Delete unused outputs to save memory.\n",
+ " del prediction_result\n",
+ " pbar.update(n=1)\n",
+ "\n",
+ " # Find the best model according to the mean pLDDT.\n",
+ " model_rank = list(plddts.keys())\n",
+ " model_rank = [model_rank[i] for i in np.argsort([plddts[x].mean() for x in model_rank])[::-1]]\n",
+ "\n",
+ " # Write out the prediction\n",
+ " pbar.set_description(f'AMBER relaxation')\n",
+ " for n,name in enumerate(model_rank):\n",
+ " pred_output_path = os.path.join(output_dir,f'model_{n+1}_unrelaxed.pdb')\n",
+ " unrelaxed_protein = unrelaxed_proteins[name]\n",
+ " pdb_lines = protein.to_pdb(unrelaxed_protein)\n",
+ " with open(pred_output_path, 'w') as f:\n",
+ " f.write(pdb_lines)\n",
+ " \n",
+ " if use_amber_relax:\n",
+ " if relax_all or n == 0:\n",
+ " amber_relaxer = relax.AmberRelaxation(\n",
+ " max_iterations=0,\n",
+ " tolerance=2.39,\n",
+ " stiffness=10.0,\n",
+ " exclude_residues=[],\n",
+ " max_outer_iterations=20)\n",
+ " relaxed_pdb_lines, _, _ = amber_relaxer.process(prot=unrelaxed_protein) \n",
+ " pred_output_path = os.path.join(output_dir,f'model_{n+1}_relaxed.pdb')\n",
+ " with open(pred_output_path, 'w') as f:\n",
+ " f.write(relaxed_pdb_lines)\n",
+ " pbar.update(n=1)\n",
+ " \n",
+ "############################################################\n",
+ "############################################################\n",
+ "\n",
+ "for n,rank in enumerate(model_rank):\n",
+ " print(f\"model_{n+1} {plddts[rank].mean()}\")\n",
+ " pae, max_pae = pae_outputs[rank]\n",
+ " # Save pLDDT and predicted aligned error (if it exists)\n",
+ " pae_output_path = os.path.join(output_dir,f'predicted_aligned_error_{n+1}.json')\n",
+ " if pae_outputs:\n",
+ " # Save predicted aligned error in the same format as the AF EMBL DB\n",
+ " rounded_errors = np.round(pae.astype(np.float64), decimals=1)\n",
+ " indices = np.indices((len(rounded_errors), len(rounded_errors))) + 1\n",
+ " indices_1 = indices[0].flatten().tolist()\n",
+ " indices_2 = indices[1].flatten().tolist()\n",
+ " pae_data = json.dumps([{\n",
+ " 'residue1': indices_1,\n",
+ " 'residue2': indices_2,\n",
+ " 'distance': rounded_errors.flatten().tolist(),\n",
+ " 'max_predicted_aligned_error': max_pae.item()\n",
+ " }],\n",
+ " indent=None,\n",
+ " separators=(',', ':'))\n",
+ " with open(pae_output_path, 'w') as f:\n",
+ " f.write(pae_data)"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KAZj6CBZTkJM",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "model_num = 1 #@param [\"1\", \"2\", \"3\", \"4\", \"5\"] {type:\"raw\"}\n",
+ "color = \"lDDT\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "def plot_plddt_legend():\n",
+ " thresh = ['plDDT:','Very low (<50)','Low (60)','OK (70)','Confident (80)','Very high (>90)']\n",
+ " plt.figure(figsize=(1,0.1),dpi=100)\n",
+ " ########################################\n",
+ " for c in [\"#FFFFFF\",\"#FF0000\",\"#FFFF00\",\"#00FF00\",\"#00FFFF\",\"#0000FF\"]:\n",
+ " plt.bar(0, 0, color=c)\n",
+ " plt.legend(thresh, frameon=False,\n",
+ " loc='center', ncol=6,\n",
+ " handletextpad=1,\n",
+ " columnspacing=1,\n",
+ " markerscale=0.5,)\n",
+ " plt.axis(False)\n",
+ " return plt\n",
+ "\n",
+ "def plot_confidence(model_num=1):\n",
+ " plt.figure(figsize=(10,3),dpi=100)\n",
+ " \"\"\"Plots the legend for plDDT.\"\"\"\n",
+ " #########################################\n",
+ " plt.subplot(1,2,1); plt.title('Predicted lDDT')\n",
+ " plt.plot(plddts[model_rank[model_num-1]])\n",
+ " for n in range(homooligomer+1):\n",
+ " x = n*(len(sequence))\n",
+ " plt.plot([x,x],[0,100],color=\"black\")\n",
+ " plt.ylabel('plDDT')\n",
+ " plt.xlabel('position')\n",
+ " #########################################\n",
+ " plt.subplot(1,2,2);plt.title('Predicted Aligned Error')\n",
+ " pae, max_pae = pae_outputs[model_rank[model_num-1]]\n",
+ " plt.imshow(pae, cmap=\"bwr\",vmin=0,vmax=30)\n",
+ " plt.colorbar()\n",
+ " plt.xlabel('Scored residue')\n",
+ " plt.ylabel('Aligned residue')\n",
+ " #########################################\n",
+ " return plt\n",
+ "\n",
+ "def show_pdb(model_num=1, show_sidechains=False, show_mainchains=False, color=\"lDDT\"):\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js',)\n",
+ " pred_output_path = os.path.join(output_dir,f'model_{model_num}_unrelaxed.pdb')\n",
+ " view.addModel(open(pred_output_path,'r').read(),'pdb')\n",
+ " if color == \"lDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':50,'max':90}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(homooligomer),list(\"ABCDEFGH\"),\n",
+ " [\"lime\",\"cyan\",\"magenta\",\"yellow\",\"salmon\",\"white\",\"blue\",\"orange\"]):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}}) \n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ "\n",
+ " view.zoomTo()\n",
+ " return view\n",
+ "\n",
+ "show_pdb(model_num,show_sidechains, show_mainchains, color).show()\n",
+ "if color == \"lDDT\": plot_plddt_legend().show() \n",
+ "plot_confidence(model_num).show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Riekgf0KQv_3",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Download prediction\n",
+ "\n",
+ "#@markdown Once this cell has been executed, a zip-archive with \n",
+ "#@markdown the obtained prediction will be automatically downloaded \n",
+ "#@markdown to your computer.\n",
+ "\n",
+ "# add settings file\n",
+ "settings_path = os.path.join(output_dir,\"settings.txt\")\n",
+ "with open(settings_path, \"w\") as text_file:\n",
+ " text_file.write(f\"sequence={sequence}\\n\")\n",
+ " text_file.write(f\"msa_method={msa_method}\\n\")\n",
+ " text_file.write(f\"homooligomer={homooligomer}\\n\")\n",
+ " text_file.write(f\"use_amber_relax={use_amber_relax}\\n\")\n",
+ " text_file.write(f\"turbo={turbo}\\n\")\n",
+ " text_file.write(f\"use_templates=False\\n\")\n",
+ "\n",
+ "# --- Download the predictions ---\n",
+ "!zip -q -r {output_dir}.zip {output_dir}\n",
+ "files.download(f'{output_dir}.zip')"
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/Alphafold_single.ipynb b/data/beta/Alphafold_single.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d5e680abf784ce72aa94fb440513547dd62ae1e7
--- /dev/null
+++ b/data/beta/Alphafold_single.ipynb
@@ -0,0 +1,270 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Alphafold_single.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iVVz9evNDNOf"
+ },
+ "source": [
+ "#AlphaFold_single"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "woIxeCPygt7K",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Install software\n",
+ "#@markdown Please execute this cell by pressing the _Play_ button \n",
+ "#@markdown on the left.\n",
+ "\n",
+ "# setup device\n",
+ "import os\n",
+ "import tensorflow as tf\n",
+ "import jax\n",
+ "\n",
+ "try:\n",
+ " # check if TPU is available\n",
+ " import jax.tools.colab_tpu\n",
+ " jax.tools.colab_tpu.setup_tpu()\n",
+ " print('Running on TPU')\n",
+ " DEVICE = \"tpu\"\n",
+ "except:\n",
+ " if jax.local_devices()[0].platform == 'cpu':\n",
+ " print(\"WARNING: no GPU detected, will be using CPU\")\n",
+ " DEVICE = \"cpu\"\n",
+ " else:\n",
+ " print('Running on GPU')\n",
+ " DEVICE = \"gpu\"\n",
+ " # disable GPU on tensorflow\n",
+ " tf.config.set_visible_devices([], 'GPU')\n",
+ "\n",
+ " \n",
+ "from IPython.utils import io\n",
+ "import subprocess\n",
+ "import tqdm.notebook\n",
+ "\n",
+ "GIT_REPO = 'https://github.com/deepmind/alphafold'\n",
+ "SOURCE_URL = 'https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar'\n",
+ "PARAMS_DIR = './alphafold/data/params'\n",
+ "PARAMS_PATH = os.path.join(PARAMS_DIR, os.path.basename(SOURCE_URL))\n",
+ "TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'\n",
+ "\n",
+ "# if not already installed\n",
+ "try:\n",
+ " with tqdm.notebook.tqdm(total=50, bar_format=TQDM_BAR_FORMAT) as pbar:\n",
+ " with io.capture_output() as captured:\n",
+ " if not os.path.isdir(\"alphafold\"):\n",
+ " %shell rm -rf alphafold\n",
+ " %shell git clone {GIT_REPO} alphafold\n",
+ " %shell (cd alphafold; git checkout 1e216f93f06aa04aa699562f504db1d02c3b704c --quiet)\n",
+ "\n",
+ " # colabfold patches\n",
+ " %shell mkdir --parents tmp\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/pairmsa.py\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/protein.patch -P tmp/\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/config.patch -P tmp/\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/model.patch -P tmp/\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/modules.patch -P tmp/\n",
+ "\n",
+ " # Apply multi-chain patch from Lim Heo @huhlim\n",
+ " %shell patch -u alphafold/alphafold/common/protein.py -i tmp/protein.patch\n",
+ " \n",
+ " # Apply patch to dynamically control number of recycles (idea from Ryan Kibler)\n",
+ " %shell patch -u alphafold/alphafold/model/model.py -i tmp/model.patch\n",
+ " %shell patch -u alphafold/alphafold/model/modules.py -i tmp/modules.patch\n",
+ " %shell patch -u alphafold/alphafold/model/config.py -i tmp/config.patch\n",
+ " pbar.update(4)\n",
+ "\n",
+ " %shell pip3 install ./alphafold\n",
+ " pbar.update(4)\n",
+ " \n",
+ " # speedup from kaczmarj\n",
+ " %shell mkdir --parents \"{PARAMS_DIR}\"\n",
+ " %shell curl -fsSL \"{SOURCE_URL}\" | tar x -C \"{PARAMS_DIR}\"\n",
+ " pbar.update(14+27)\n",
+ "\n",
+ " # Install py3dmol.\n",
+ " %shell pip install py3dmol\n",
+ " pbar.update(1)\n",
+ " else:\n",
+ " pbar.update(50)\n",
+ "\n",
+ "except subprocess.CalledProcessError:\n",
+ " print(captured)\n",
+ " raise\n",
+ "\n",
+ "########################################################################################\n",
+ "# --- Python imports ---\n",
+ "import colabfold as cf\n",
+ "import sys\n",
+ "\n",
+ "from google.colab import files\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import py3Dmol\n",
+ "\n",
+ "from alphafold.model import model\n",
+ "from alphafold.model import config\n",
+ "from alphafold.model import data\n",
+ "from alphafold.data import pipeline\n",
+ "from alphafold.common import protein\n",
+ "\n",
+ "from alphafold.model.tf import shape_placeholders\n",
+ "\n",
+ "def make_fixed_size(feat, shape_schema, num_res=100, msa_cluster_size=1, extra_msa_size=1, num_templates=0):\n",
+ " \"\"\"Guess at the MSA and sequence dimensions to make fixed size.\"\"\"\n",
+ " pad_size_map = {\n",
+ " shape_placeholders.NUM_RES: num_res,\n",
+ " shape_placeholders.NUM_MSA_SEQ: msa_cluster_size,\n",
+ " shape_placeholders.NUM_EXTRA_SEQ: extra_msa_size,\n",
+ " shape_placeholders.NUM_TEMPLATES: num_templates,\n",
+ " }\n",
+ " for k, v in feat.items():\n",
+ " # Don't transfer this to the accelerator.\n",
+ " if k == 'extra_cluster_assignment':\n",
+ " continue\n",
+ " shape = list(v.shape)\n",
+ " schema = shape_schema[k]\n",
+ " assert len(shape) == len(schema), (\n",
+ " f'Rank mismatch between shape and shape schema for {k}: '\n",
+ " f'{shape} vs {schema}')\n",
+ " pad_size = [pad_size_map.get(s2, None) or s1 for (s1, s2) in zip(shape, schema)]\n",
+ " padding = [(0, p - tf.shape(v)[i]) for i, p in enumerate(pad_size)]\n",
+ " if padding:\n",
+ " feat[k] = tf.pad(v, padding, name=f'pad_to_fixed_{k}')\n",
+ " feat[k].set_shape(pad_size)\n",
+ " return {k:np.asarray(v) for k,v in feat.items()}\n",
+ "\n",
+ "def parse_results(prediction_result, processed_feature_dict):\n",
+ " b_factors = prediction_result['plddt'][:,None] * prediction_result['structure_module']['final_atom_mask'] \n",
+ " dist_bins = jax.numpy.append(0,prediction_result[\"distogram\"][\"bin_edges\"])\n",
+ " dist_mtx = dist_bins[prediction_result[\"distogram\"][\"logits\"].argmax(-1)]\n",
+ " contact_mtx = jax.nn.softmax(prediction_result[\"distogram\"][\"logits\"])[:,:,dist_bins < 8].sum(-1)\n",
+ "\n",
+ " out = {\"unrelaxed_protein\": protein.from_prediction(processed_feature_dict, prediction_result, b_factors=b_factors),\n",
+ " \"plddt\": prediction_result['plddt'],\n",
+ " \"pLDDT\": prediction_result['plddt'].mean(),\n",
+ " \"dists\": dist_mtx,\n",
+ " \"adj\": contact_mtx}\n",
+ "\n",
+ " if \"ptm\" in prediction_result:\n",
+ " out.update({\"pae\": prediction_result['predicted_aligned_error'],\n",
+ " \"pTMscore\": prediction_result['ptm']})\n",
+ " return out\n",
+ "\n",
+ "if \"model_runner\" not in dir():\n",
+ " name = \"model_5_ptm\"\n",
+ " model_config = config.model_config(name)\n",
+ " model_config.data.eval.max_msa_clusters = 1\n",
+ " model_config.data.common.max_extra_msa = 1\n",
+ " model_config.model.num_recycle = 2\n",
+ " model_config.data.common.num_recycle = 2\n",
+ "\n",
+ " model_runner = model.RunModel(model_config, data.get_model_haiku_params(name,'./alphafold/data'))\n",
+ "\n",
+ " eval_cfg = model_runner.config.data.eval\n",
+ " crop_feats = {k:[None]+v for k,v in dict(eval_cfg.feat).items()} \n",
+ "\n",
+ " MAX_LEN = 100 "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "rowN0bVYLe9n",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Enter the amino acid sequence to fold ⬇️\n",
+ "import re\n",
+ "\n",
+ "# define sequence\n",
+ "sequence = 'GGGGGGGGGGGGGGGGGGG' #@param {type:\"string\"}\n",
+ "sequence = re.sub(\"[^A-Z]\", \"\", sequence.upper())\n",
+ "\n",
+ "msas, deletion_matrices = [],[]\n",
+ "msas.append([sequence])\n",
+ "deletion_matrices.append([[0]*len(sequence)])\n",
+ "\n",
+ "num_res = len(sequence)\n",
+ "feature_dict = {**pipeline.make_sequence_features(sequence, 'test', num_res),\n",
+ " **pipeline.make_msa_features(msas, deletion_matrices=deletion_matrices)}\n",
+ "\n",
+ "if num_res > MAX_LEN:\n",
+ " MAX_LEN = num_res\n",
+ "\n",
+ "# process features\n",
+ "processed_feature_dict = model_runner.process_features(feature_dict, random_seed=0)\n",
+ "processed_feature_dict = make_fixed_size(processed_feature_dict, crop_feats, num_res=MAX_LEN)\n",
+ "\n",
+ "# predict\n",
+ "prediction_result, (r, t) = model_runner.predict(processed_feature_dict)\n",
+ "\n",
+ "# save results\n",
+ "outs = parse_results(prediction_result, processed_feature_dict)\n",
+ "outs.update({\"recycles\":r, \"tol\":t})\n",
+ "with open(\"out.pdb\", 'w') as f: f.write(protein.to_pdb(outs[\"unrelaxed_protein\"]))"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KAZj6CBZTkJM",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "color = \"chain\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "cf.show_pdb(\"out.pdb\", show_sidechains, show_mainchains, color,\n",
+ " color_HP=True, size=(800,480)).show()\n",
+ "if color == \"lDDT\":\n",
+ " cf.plot_plddt_legend().show() \n",
+ "if \"pae\" in outs:\n",
+ " cf.plot_confidence(outs[\"plddt\"][:num_res], outs[\"pae\"][:num_res,:][:,:num_res]).show()\n",
+ "else:\n",
+ " cf.plot_confidence(outs[\"plddt\"][:num_res]).show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/ESMFold.ipynb b/data/beta/ESMFold.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..049a36415383ea981a3e762d09b89570167c155d
--- /dev/null
+++ b/data/beta/ESMFold.ipynb
@@ -0,0 +1,474 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AMwhSNWEzRCZ"
+ },
+ "source": [
+ "#**ESMFold**\n",
+ "for more details see: [Github](https://github.com/facebookresearch/esm/tree/main/esm), [Preprint](https://www.biorxiv.org/content/10.1101/2022.07.20.500902v1)\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "\n",
+ "#### **Colab Limitations**\n",
+ "- On Tesla T4 (typical free colab GPU), max total length ~ 900\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "catNptjYwNM6",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "%%time\n",
+ "#@title install\n",
+ "#@markdown install ESMFold, OpenFold and download Params (~2min 30s)\n",
+ "import os,sys\n",
+ "from IPython.utils import io\n",
+ "import time\n",
+ "if not os.path.isfile(\"esmfold.model\"):\n",
+ " with io.capture_output() as captured:\n",
+ " # download esmfold params\n",
+ " os.system(\"apt-get install aria2 -qq\")\n",
+ " os.system(\"aria2c -q -x 16 https://files.ipd.uw.edu/pub/esmfold/esmfold.model &\")\n",
+ "\n",
+ " # install libs\n",
+ " os.system(\"pip install -q omegaconf pytorch_lightning biopython ml_collections einops py3Dmol\")\n",
+ " os.system(\"pip install -q git+https://github.com/NVIDIA/dllogger.git\")\n",
+ "\n",
+ " # install esmfold (will be replaced later with github)\n",
+ " os.system(\"wget -qnc https://files.ipd.uw.edu/pub/esmfold/esmfold_beta.zip; unzip -qqo esmfold_beta.zip\")\n",
+ "\n",
+ " # install openfold\n",
+ " commit = \"6908936b68ae89f67755240e2f588c09ec31d4c8\"\n",
+ " os.system(f\"pip install -q git+https://github.com/aqlaboratory/openfold.git@{commit}\")\n",
+ " \n",
+ " # wait for Params to finish downloading...\n",
+ " if not os.path.isfile(\"esmfold.model\"):\n",
+ " # backup source!\n",
+ " os.system(\"aria2c -q -x 16 https://colabfold.steineggerlab.workers.dev/esm/esmfold.model\")\n",
+ " else:\n",
+ " while os.path.isfile(\"esmfold.model.aria2\"):\n",
+ " time.sleep(5)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "2rqTrvifh17B",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "#@title ##run **ESMFold**\n",
+ "%%time\n",
+ "from string import ascii_uppercase, ascii_lowercase\n",
+ "import hashlib, re, os\n",
+ "import numpy as np\n",
+ "from jax.tree_util import tree_map\n",
+ "import matplotlib.pyplot as plt\n",
+ "from scipy.special import softmax\n",
+ "\n",
+ "def parse_output(output):\n",
+ " pae = (output[\"aligned_confidence_probs\"][0] * np.arange(64)).mean(-1) * 31\n",
+ " plddt = output[\"plddt\"][0,:,1] * 100\n",
+ " \n",
+ " bins = np.append(0,np.linspace(2.3125,21.6875,63))\n",
+ " sm_contacts = softmax(output[\"distogram_logits\"],-1)[0]\n",
+ " sm_contacts = sm_contacts[...,bins<8].sum(-1)\n",
+ " xyz = output[\"positions\"][-1,0,:,1]\n",
+ " mask = output[\"atom37_atom_exists\"][0,:,1] == 1\n",
+ " o = {\"pae\":pae[mask,:][:,mask],\n",
+ " \"plddt\":plddt[mask],\n",
+ " \"sm_contacts\":sm_contacts[mask,:][:,mask],\n",
+ " \"xyz\":xyz[mask]}\n",
+ " if \"contacts\" in output[\"lm_output\"]:\n",
+ " lm_contacts = output[\"lm_output\"][\"contacts\"].astype(float)[0]\n",
+ " o[\"lm_contacts\"] = lm_contacts[mask,:][:,mask]\n",
+ " return o\n",
+ "\n",
+ "def get_hash(x): return hashlib.sha1(x.encode()).hexdigest()\n",
+ "alphabet_list = list(ascii_uppercase+ascii_lowercase)\n",
+ "\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "jobname = re.sub(r'\\W+', '', jobname)[:50]\n",
+ "\n",
+ "sequence = \"GWSTELEKHREELKEFLKKEGITNVEIRIDNGRLEVRVEGGTERLKRFLEELRQKLEKKGYTVDIKIE\" #@param {type:\"string\"}\n",
+ "sequence = re.sub(\"[^A-Z:]\", \"\", sequence.replace(\"/\",\":\").upper())\n",
+ "sequence = re.sub(\":+\",\":\",sequence)\n",
+ "sequence = re.sub(\"^[:]+\",\"\",sequence)\n",
+ "sequence = re.sub(\"[:]+$\",\"\",sequence)\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown ###**Advanced Options**\n",
+ "num_recycles = 3 #@param [\"0\", \"1\", \"2\", \"3\", \"6\", \"12\"] {type:\"raw\"}\n",
+ "get_LM_contacts = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "#@markdown **multimer options (experimental)**\n",
+ "#@markdown - use \"/\" to specify chainbreaks, (eg. sequence=\"AAA/AAA\")\n",
+ "#@markdown - for homo-oligomeric predictions, set copies > 1\n",
+ "\n",
+ "copies = 1 #@param {type:\"integer\"}\n",
+ "chain_linker = 25 #@param {type:\"raw\"}\n",
+ "if copies == \"\" or copies <= 0: copies = 1\n",
+ "sequence = \":\".join([sequence] * copies)\n",
+ "\n",
+ "#@markdown **sampling options (experimental)**\n",
+ "#@markdown - Samples are generated via random masking (defined by `masking_rate`) \n",
+ "#@markdown of input sequence (stochastic_mode=\"LM\") and/or via dropout within structure module (stochastic_mode=\"SM\").\n",
+ "samples = None #@param [\"None\", \"1\", \"4\", \"8\", \"16\", \"32\", \"64\"] {type:\"raw\"}\n",
+ "masking_rate = 0.15 #@param {type:\"raw\"}\n",
+ "stochastic_mode = \"LM\" #@param [\"LM\", \"LM_SM\", \"SM\"]\n",
+ "\n",
+ "ID = jobname+\"_\"+get_hash(sequence)[:5]\n",
+ "seqs = sequence.split(\":\")\n",
+ "lengths = [len(s) for s in seqs]\n",
+ "length = sum(lengths)\n",
+ "print(\"length\",length)\n",
+ "\n",
+ "u_seqs = list(set(seqs))\n",
+ "if len(seqs) == 1: mode = \"mono\"\n",
+ "elif len(u_seqs) == 1: mode = \"homo\"\n",
+ "else: mode = \"hetero\"\n",
+ "\n",
+ "if \"model\" not in dir():\n",
+ " import torch\n",
+ " model = torch.load(\"esmfold.model\")\n",
+ " model.cuda().requires_grad_(False)\n",
+ "\n",
+ "# optimized for Tesla T4\n",
+ "if length > 700:\n",
+ " model.trunk.set_chunk_size(64)\n",
+ "else:\n",
+ " model.trunk.set_chunk_size(128)\n",
+ "\n",
+ "best_pdb_str = None\n",
+ "best_ptm = 0\n",
+ "best_output = None\n",
+ "traj = []\n",
+ "\n",
+ "num_samples = 1 if samples is None else samples\n",
+ "for seed in range(num_samples):\n",
+ " torch.cuda.empty_cache()\n",
+ " if samples is None:\n",
+ " seed = \"default\"\n",
+ " mask_rate = 0.0\n",
+ " model.train(False)\n",
+ " else:\n",
+ " torch.manual_seed(seed)\n",
+ " mask_rate = masking_rate if \"LM\" in stochastic_mode else 0.0\n",
+ " model.train(\"SM\" in stochastic_mode)\n",
+ "\n",
+ " output = model.infer(sequence,\n",
+ " num_recycles=num_recycles+1,\n",
+ " chain_linker=\"X\"*chain_linker,\n",
+ " residue_index_offset=512,\n",
+ " mask_rate=mask_rate,\n",
+ " return_contacts=get_LM_contacts)\n",
+ " \n",
+ " pdb_str = model.output_to_pdb(output)[0]\n",
+ " output = tree_map(lambda x: x.cpu().numpy(), output)\n",
+ " ptm = output[\"ptm\"]\n",
+ " plddt = output[\"plddt\"][...,1].mean()\n",
+ " traj.append(parse_output(output))\n",
+ " print(f'{seed} ptm: {ptm:.3f} plddt: {plddt:.3f}')\n",
+ " if ptm > best_ptm:\n",
+ " best_pdb_str = pdb_str\n",
+ " best_ptm = ptm\n",
+ " best_output = output\n",
+ " os.system(f\"mkdir -p {ID}\")\n",
+ " if samples is None:\n",
+ " pdb_filename = f\"{ID}/ptm{ptm:.3f}_r{num_recycles}_{seed}.pdb\"\n",
+ " else:\n",
+ " pdb_filename = f\"{ID}/ptm{ptm:.3f}_r{num_recycles}_seed{seed}_{stochastic_mode}_mr{masking_rate:.2f}.pdb\"\n",
+ "\n",
+ " with open(pdb_filename,\"w\") as out:\n",
+ " out.write(pdb_str)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "tg7eFMC-TYRX"
+ },
+ "outputs": [],
+ "source": [
+ "#@title display (optional) {run: \"auto\"}\n",
+ "#@markdown Note: If samples selected, the model with max pTM is displayed.\n",
+ "import py3Dmol\n",
+ "\n",
+ "\n",
+ "pymol_color_list = [\"#33ff33\",\"#00ffff\",\"#ff33cc\",\"#ffff00\",\"#ff9999\",\"#e5e5e5\",\"#7f7fff\",\"#ff7f00\",\n",
+ " \"#7fff7f\",\"#199999\",\"#ff007f\",\"#ffdd5e\",\"#8c3f99\",\"#b2b2b2\",\"#007fff\",\"#c4b200\",\n",
+ " \"#8cb266\",\"#00bfbf\",\"#b27f7f\",\"#fcd1a5\",\"#ff7f7f\",\"#ffbfdd\",\"#7fffff\",\"#ffff7f\",\n",
+ " \"#00ff7f\",\"#337fcc\",\"#d8337f\",\"#bfff3f\",\"#ff7fff\",\"#d8d8ff\",\"#3fffbf\",\"#b78c4c\",\n",
+ " \"#339933\",\"#66b2b2\",\"#ba8c84\",\"#84bf00\",\"#b24c66\",\"#7f7f7f\",\"#3f3fa5\",\"#a5512b\"]\n",
+ "\n",
+ "def show_pdb(pdb_str, show_sidechains=False, show_mainchains=False,\n",
+ " color=\"pLDDT\", chains=None, vmin=50, vmax=90,\n",
+ " size=(800,480), hbondCutoff=4.0,\n",
+ " Ls=None,\n",
+ " animate=False):\n",
+ " \n",
+ " if chains is None:\n",
+ " chains = 1 if Ls is None else len(Ls)\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js', width=size[0], height=size[1])\n",
+ " if animate:\n",
+ " view.addModelsAsFrames(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " else:\n",
+ " view.addModel(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " if color == \"pLDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':vmin,'max':vmax}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}}) \n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.zoomTo()\n",
+ " if animate: view.animate()\n",
+ " return view\n",
+ "\n",
+ "color = \"confidence\" #@param [\"confidence\", \"rainbow\", \"chain\"]\n",
+ "if color == \"confidence\": color = \"pLDDT\"\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "show_pdb(best_pdb_str, color=color,\n",
+ " show_sidechains=show_sidechains,\n",
+ " show_mainchains=show_mainchains,\n",
+ " Ls=lengths).show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "hkiKtX43voI-"
+ },
+ "outputs": [],
+ "source": [
+ "#@title plot confidence (optional)\n",
+ "#@markdown Note: If samples selected, the model with max pTM is displayed.\n",
+ "\n",
+ "dpi = 100 #@param {type:\"integer\"}\n",
+ "\n",
+ "def plot_ticks(Ls):\n",
+ " Ln = sum(Ls)\n",
+ " L_prev = 0\n",
+ " for L_i in Ls[:-1]:\n",
+ " L = L_prev + L_i\n",
+ " L_prev += L_i\n",
+ " plt.plot([0,Ln],[L,L],color=\"black\")\n",
+ " plt.plot([L,L],[0,Ln],color=\"black\")\n",
+ " ticks = np.cumsum([0]+Ls)\n",
+ " ticks = (ticks[1:] + ticks[:-1])/2\n",
+ " plt.yticks(ticks,alphabet_list[:len(ticks)])\n",
+ "\n",
+ "def plot_confidence(output, Ls=None, dpi=100):\n",
+ " O = parse_output(output)\n",
+ " if \"lm_contacts\" in O:\n",
+ " plt.figure(figsize=(20,4), dpi=dpi)\n",
+ " plt.subplot(1,4,1)\n",
+ " else:\n",
+ " plt.figure(figsize=(15,4), dpi=dpi)\n",
+ " plt.subplot(1,3,1)\n",
+ "\n",
+ " plt.title('Predicted lDDT')\n",
+ " plt.plot(O[\"plddt\"])\n",
+ " if Ls is not None:\n",
+ " L_prev = 0\n",
+ " for L_i in Ls[:-1]:\n",
+ " L = L_prev + L_i\n",
+ " L_prev += L_i\n",
+ " plt.plot([L,L],[0,100],color=\"black\")\n",
+ " plt.xlim(0,O[\"plddt\"].shape[0])\n",
+ " plt.ylim(0,100)\n",
+ " plt.ylabel('plDDT')\n",
+ " plt.xlabel('position')\n",
+ " plt.subplot(1,4 if \"lm_contacts\" in O else 3,2)\n",
+ "\n",
+ " plt.title('Predicted Aligned Error')\n",
+ " Ln = O[\"pae\"].shape[0]\n",
+ " plt.imshow(O[\"pae\"],cmap=\"bwr\",vmin=0,vmax=30,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " plt.colorbar()\n",
+ " plt.xlabel('Scored residue')\n",
+ " plt.ylabel('Aligned residue')\n",
+ "\n",
+ " if \"lm_contacts\" in O:\n",
+ " plt.subplot(1,4,3)\n",
+ " plt.title(\"contacts from LM\")\n",
+ " plt.imshow(O[\"lm_contacts\"],cmap=\"Greys\",vmin=0,vmax=1,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " plt.subplot(1,4,4)\n",
+ " else:\n",
+ " plt.subplot(1,3,3)\n",
+ " plt.title(\"contacts from Structure Module\")\n",
+ " plt.imshow(O[\"sm_contacts\"],cmap=\"Greys\",vmin=0,vmax=1,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " return plt\n",
+ "\n",
+ "plot_confidence(best_output, Ls=lengths, dpi=dpi)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title download predictions\n",
+ "from google.colab import files\n",
+ "os.system(f\"zip {ID}.zip {ID}/*\")\n",
+ "files.download(f'{ID}.zip')"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "AVn1z6H9o7GT"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title animate outputs (optional)\n",
+ "#@markdown if more than one sample generated\n",
+ "import os\n",
+ "if not os.path.isdir(\"colabfold\"):\n",
+ " os.system(\"git clone https://github.com/sokrypton/ColabFold.git\")\n",
+ "import ColabFold.beta.colabfold as cf\n",
+ "\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "color_by_plddt = True #@param {type:\"boolean\"}\n",
+ "use_pca = True\n",
+ "cycle = True \n",
+ "\n",
+ "import matplotlib\n",
+ "from matplotlib import animation\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.decomposition import PCA\n",
+ "\n",
+ "def mk_animation(xyz, labels, plddt, ref=0, Ls=None, line_w=2.0, dpi=100,color_by_plddt=False):\n",
+ "\n",
+ " def ca_align_to_last(positions, ref):\n",
+ " def align(P, Q):\n",
+ " if Ls is None or len(Ls) == 1:\n",
+ " P_,Q_ = P,Q\n",
+ " else:\n",
+ " # align relative to first chain\n",
+ " P_,Q_ = P[:Ls[0]],Q[:Ls[0]]\n",
+ " p = P_ - P_.mean(0,keepdims=True)\n",
+ " q = Q_ - Q_.mean(0,keepdims=True)\n",
+ " return ((P - P_.mean(0,keepdims=True)) @ cf.kabsch(p,q)) + Q_.mean(0,keepdims=True)\n",
+ " \n",
+ " pos = positions[ref] - positions[ref].mean(0,keepdims=True)\n",
+ " best_2D_view = pos @ cf.kabsch(pos,pos,return_v=True)\n",
+ "\n",
+ " new_positions = []\n",
+ " for i in range(len(positions)):\n",
+ " new_positions.append(align(positions[i],best_2D_view))\n",
+ " return np.asarray(new_positions)\n",
+ "\n",
+ " # align to reference \n",
+ " pos = ca_align_to_last(xyz, ref)\n",
+ "\n",
+ " fig, (ax1) = plt.subplots(1)\n",
+ " fig.set_figwidth(5)\n",
+ " fig.set_figheight(5)\n",
+ " fig.set_dpi(dpi)\n",
+ "\n",
+ " xy_min = pos[...,:2].min() - 1\n",
+ " xy_max = pos[...,:2].max() + 1\n",
+ "\n",
+ " for ax in [ax1]:\n",
+ " ax.set_xlim(xy_min, xy_max)\n",
+ " ax.set_ylim(xy_min, xy_max)\n",
+ " ax.axis(False)\n",
+ "\n",
+ " ims=[]\n",
+ " for l,pos_,plddt_ in zip(labels,pos,plddt):\n",
+ " if color_by_plddt:\n",
+ " img = cf.plot_pseudo_3D(pos_, c=plddt_, cmin=50, cmax=90, line_w=line_w, ax=ax1) \n",
+ " elif Ls is None or len(Ls) == 1:\n",
+ " img = cf.plot_pseudo_3D(pos_, ax=ax1, line_w=line_w)\n",
+ " else:\n",
+ " c = np.concatenate([[n]*L for n,L in enumerate(Ls)])\n",
+ " img = cf.plot_pseudo_3D(pos_, c=c, cmap=cf.pymol_cmap, cmin=0, cmax=39, line_w=line_w, ax=ax1)\n",
+ " ims.append([cf.add_text(f\"{l}\", ax1),img])\n",
+ " \n",
+ " ani = animation.ArtistAnimation(fig, ims, blit=True, interval=120)\n",
+ " plt.close()\n",
+ " return ani.to_html5_video()\n",
+ "\n",
+ "labels = np.array([f\"seed:{x}\" for x in range(len(traj))])\n",
+ "pos = np.array([x[\"xyz\"] for x in traj])\n",
+ "plddt = np.array([x[\"plddt\"] for x in traj])\n",
+ "if use_pca and pos.shape[0] > 1:\n",
+ " pos_ca = pos\n",
+ " if lengths is not None and len(lengths) > 1:\n",
+ " pos_ca = pos_ca[:,:lengths[0]]\n",
+ " i,j = np.triu_indices(pos_ca.shape[1],k=1)\n",
+ " pos_ca_dm = np.sqrt(np.square(pos_ca[:,None,:,:] - pos_ca[:,:,None]).sum(-1))[:,i,j]\n",
+ " pc = PCA(1).fit_transform(pos_ca_dm)[:,0].argsort()\n",
+ " if cycle:\n",
+ " pc = np.append(pc,pc[1:-1][::-1])\n",
+ " pos = pos[pc]\n",
+ " labels = labels[pc]\n",
+ " plddt = plddt[pc]\n",
+ "HTML(mk_animation(pos, labels, plddt, Ls=lengths, dpi=dpi, color_by_plddt=color_by_plddt))"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "NY8H_iM5WFUu"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "gpuClass": "standard",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/data/beta/ESMFold_advanced.ipynb b/data/beta/ESMFold_advanced.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..344a258a90571235f1097d5a5ceb2298e2eba526
--- /dev/null
+++ b/data/beta/ESMFold_advanced.ipynb
@@ -0,0 +1,584 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AMwhSNWEzRCZ"
+ },
+ "source": [
+ "#**ESMFold_advanced**\n",
+ "for more details see: [Github](https://github.com/facebookresearch/esm/tree/main/esm), [Preprint](https://www.biorxiv.org/content/10.1101/2022.07.20.500902v1)\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "\n",
+ "#### **Colab Limitations**\n",
+ "- On Tesla T4 (typical free colab GPU), max total length ~ 900\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "catNptjYwNM6",
+ "cellView": "form"
+ },
+ "outputs": [],
+ "source": [
+ "%%time\n",
+ "#@title install\n",
+ "#@markdown install ESMFold, OpenFold and download Params (~2min 30s)\n",
+ "\n",
+ "import os, time\n",
+ "import torch\n",
+ "if not os.path.isfile(\"esmfold.model\"):\n",
+ " # download esmfold params\n",
+ " os.system(\"apt-get install aria2 -qq\")\n",
+ " os.system(\"aria2c -q -x 16 https://colabfold.steineggerlab.workers.dev/esm/esmfold.model &\")\n",
+ "\n",
+ " # install libs\n",
+ " print(\"installing libs...\")\n",
+ " os.system(\"pip install -q omegaconf pytorch_lightning biopython ml_collections einops py3Dmol modelcif\")\n",
+ " os.system(\"pip install -q git+https://github.com/NVIDIA/dllogger.git\")\n",
+ "\n",
+ " print(\"installing openfold...\")\n",
+ " # install openfold\n",
+ " os.system(f\"pip install -q git+https://github.com/sokrypton/openfold.git\")\n",
+ "\n",
+ " print(\"installing esmfold...\")\n",
+ " # install esmfold\n",
+ " os.system(f\"pip install -q git+https://github.com/sokrypton/esm.git@beta\")\n",
+ "\n",
+ " # wait for Params to finish downloading...\n",
+ " if not os.path.isfile(\"esmfold.model\"):\n",
+ " # backup source!\n",
+ " os.system(\"aria2c -q -x 16 https://files.ipd.uw.edu/pub/esmfold/esmfold.model\")\n",
+ " else:\n",
+ " while os.path.isfile(\"esmfold.model.aria2\"):\n",
+ " time.sleep(5)\n",
+ "\n",
+ "if \"model\" not in dir():\n",
+ " model_path = \"esmfold.model\"\n",
+ " model = torch.load(model_path, weights_only=False)\n",
+ " model.cuda().requires_grad_(False)\n",
+ "\n",
+ "import os\n",
+ "import re\n",
+ "import hashlib\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "from string import ascii_uppercase, ascii_lowercase\n",
+ "from jax.tree_util import tree_map\n",
+ "from scipy.special import softmax\n",
+ "from typing import Optional\n",
+ "\n",
+ "def get_hash(x: str) -> str:\n",
+ " \"\"\"Generates a SHA1 hash for a given string.\"\"\"\n",
+ " return hashlib.sha1(x.encode()).hexdigest()\n",
+ "\n",
+ "def parse_output(output: dict) -> dict:\n",
+ " \"\"\"\n",
+ " Parses the raw model output dictionary to extract key metrics and structures.\n",
+ "\n",
+ " Args:\n",
+ " output: The raw dictionary from model.infer().\n",
+ "\n",
+ " Returns:\n",
+ " A dictionary containing pae, plddt, contacts, and xyz coordinates.\n",
+ " \"\"\"\n",
+ " pae = (output[\"aligned_confidence_probs\"][0] * np.arange(64)).mean(-1) * 31\n",
+ " plddt = output[\"plddt\"][0, :, 1]\n",
+ "\n",
+ " bins = np.append(0, np.linspace(2.3125, 21.6875, 63))\n",
+ " sm_contacts = softmax(output[\"distogram_logits\"], -1)[0]\n",
+ " sm_contacts = sm_contacts[..., bins < 8].sum(-1)\n",
+ " xyz = output[\"positions\"][-1, 0, :, 1]\n",
+ " mask = output[\"atom37_atom_exists\"][0, :, 1] == 1\n",
+ "\n",
+ " o = {\"pae\": pae[mask, :][:, mask],\n",
+ " \"plddt\": plddt[mask],\n",
+ " \"sm_contacts\": sm_contacts[mask, :][:, mask],\n",
+ " \"xyz\": xyz[mask]}\n",
+ "\n",
+ " if \"contacts\" in output[\"lm_output\"]:\n",
+ " lm_contacts = output[\"lm_output\"][\"contacts\"].astype(float)[0]\n",
+ " o[\"lm_contacts\"] = lm_contacts[mask, :][:, mask]\n",
+ "\n",
+ " return o\n",
+ "\n",
+ "# --- Main Prediction Function ---\n",
+ "\n",
+ "def predict_esmfold(\n",
+ " model: torch.nn.Module,\n",
+ " sequence: str,\n",
+ " jobname: str = \"test\",\n",
+ " num_recycles: int = 3,\n",
+ " get_LM_contacts: bool = False,\n",
+ " copies: int = 1,\n",
+ " chain_linker: int = 25,\n",
+ " samples: Optional[int] = None,\n",
+ " masking_rate: float = 0.15,\n",
+ " stochastic_mode: str = \"LM\",\n",
+ " save_dir: str = \".\",\n",
+ " verbose=False\n",
+ ") -> dict:\n",
+ " \"\"\"\n",
+ " Runs ESMFold prediction for a given sequence and parameters.\n",
+ "\n",
+ " Args:\n",
+ " model: The loaded ESMFold torch model.\n",
+ " sequence: The amino acid sequence (e.g., \"GWSTELEKH...\").\n",
+ " jobname: A name for the prediction job.\n",
+ " num_recycles: Number of recycling iterations (0, 1, 2, 3, 6, 12).\n",
+ " get_LM_contacts: Whether to return language model contacts.\n",
+ " copies: Number of copies for homo-oligomeric predictions.\n",
+ " chain_linker: Length of the 'X' linker for multimers.\n",
+ " samples: Number of stochastic samples (None, 1, 4, 8, 16, 32, 64).\n",
+ " masking_rate: Masking rate for stochastic LM sampling.\n",
+ " stochastic_mode: Type of stochastic sampling (\"LM\", \"LM_SM\", \"SM\").\n",
+ " save_dir: Directory to save PDB files and results.\n",
+ "\n",
+ " Returns:\n",
+ " A dictionary containing:\n",
+ " - \"best_output\": Raw output dictionary of the best model.\n",
+ " - \"best_pdb_str\": PDB string of the best model (highest ptm).\n",
+ " - \"best_ptm\": The ptm score of the best model.\n",
+ " - \"trajectory\": A list of parsed outputs for each sample.\n",
+ " - \"prediction_dir\": The specific directory where results were saved.\n",
+ " \"\"\"\n",
+ "\n",
+ " # --- Input Processing ---\n",
+ " jobname = re.sub(r'\\W+', '', jobname)[:50]\n",
+ "\n",
+ " # Clean sequence\n",
+ " sequence = re.sub(\"[^A-Z:]\", \"\", sequence.replace(\"/\", \":\").upper())\n",
+ " sequence = re.sub(\":+\", \":\", sequence)\n",
+ " sequence = re.sub(\"^[:]+\", \"\", sequence)\n",
+ " sequence = re.sub(\"[:]+$\", \"\", sequence)\n",
+ "\n",
+ " if copies <= 0:\n",
+ " copies = 1\n",
+ " sequence = \":\".join([sequence] * copies)\n",
+ "\n",
+ " seqs = sequence.split(\":\")\n",
+ " lengths = [len(s) for s in seqs]\n",
+ " length = sum(lengths)\n",
+ " if verbose:\n",
+ " print(f\"Running prediction for job '{jobname}' with length {length}\")\n",
+ "\n",
+ " ID = jobname + \"_\" + get_hash(sequence)[:5]\n",
+ " prediction_dir = os.path.join(save_dir, ID)\n",
+ " os.makedirs(prediction_dir, exist_ok=True)\n",
+ "\n",
+ " # --- Model Configuration ---\n",
+ " # Optimized for Tesla T4\n",
+ " if length > 700:\n",
+ " model.trunk.set_chunk_size(64)\n",
+ " else:\n",
+ " model.trunk.set_chunk_size(128)\n",
+ "\n",
+ " if not next(model.parameters()).is_cuda:\n",
+ " print(\"Warning: Model is not on CUDA. Moving to CUDA.\")\n",
+ " model.cuda()\n",
+ " model.requires_grad_(False)\n",
+ "\n",
+ " # --- Prediction Loop ---\n",
+ " best_pdb_str = None\n",
+ " best_ptm = 0\n",
+ " best_output = None\n",
+ " traj = []\n",
+ "\n",
+ " num_samples = 1 if samples is None else samples\n",
+ "\n",
+ " for seed in range(num_samples):\n",
+ " torch.cuda.empty_cache()\n",
+ "\n",
+ " current_seed_str = \"default\"\n",
+ " mask_rate = 0.0\n",
+ " model.train(False) # Set to eval mode by default\n",
+ "\n",
+ " if samples is not None:\n",
+ " torch.manual_seed(seed)\n",
+ " current_seed_str = f\"seed{seed}\"\n",
+ " mask_rate = masking_rate if \"LM\" in stochastic_mode else 0.0\n",
+ " model.train(\"SM\" in stochastic_mode) # Set to train mode for dropout\n",
+ "\n",
+ " if verbose:\n",
+ " print(f\"Running sample {seed + 1}/{num_samples} (seed: {current_seed_str})...\")\n",
+ "\n",
+ " output = model.infer(\n",
+ " sequence,\n",
+ " num_recycles=num_recycles,\n",
+ " chain_linker=\"X\" * chain_linker,\n",
+ " residue_index_offset=512,\n",
+ " mask_rate=mask_rate,\n",
+ " return_contacts=get_LM_contacts\n",
+ " )\n",
+ "\n",
+ " pdb_str = model.output_to_pdb(output)[0]\n",
+ " output = tree_map(lambda x: x.cpu().numpy(), output)\n",
+ " ptm = output[\"ptm\"][0]\n",
+ " plddt = output[\"plddt\"][0, :, 1].mean()\n",
+ " traj.append(parse_output(output))\n",
+ "\n",
+ " if verbose:\n",
+ " print(f'Sample {seed} ptm: {ptm:.3f} plddt: {plddt:.1f}')\n",
+ "\n",
+ " if ptm > best_ptm:\n",
+ " best_pdb_str = pdb_str\n",
+ " best_ptm = ptm\n",
+ " best_output = output\n",
+ "\n",
+ " # --- Save PDB File ---\n",
+ " if samples is None:\n",
+ " pdb_filename = f\"ptm{ptm:.3f}_r{num_recycles}_{current_seed_str}.pdb\"\n",
+ " else:\n",
+ " pdb_filename = (\n",
+ " f\"ptm{ptm:.3f}_r{num_recycles}_{current_seed_str}_\"\n",
+ " f\"{stochastic_mode}_m{masking_rate:.2f}.pdb\"\n",
+ " )\n",
+ "\n",
+ " pdb_path = os.path.join(prediction_dir, pdb_filename)\n",
+ " with open(pdb_path, \"w\") as f:\n",
+ " f.write(pdb_str)\n",
+ " if verbose:\n",
+ " print(f\"Saved PDB to {pdb_path}\")\n",
+ "\n",
+ " if verbose:\n",
+ " print(f\"Prediction complete. Best ptm: {best_ptm:.3f}\")\n",
+ "\n",
+ " return {\n",
+ " \"output\": best_output,\n",
+ " \"pdb_str\": best_pdb_str,\n",
+ " \"ptm\": best_ptm,\n",
+ " \"traj\": traj,\n",
+ " \"dir\": prediction_dir,\n",
+ " \"lengths\":lengths\n",
+ " }\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title ##run **ESMFold**\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "sequence = \"GWSTELEKHREELKEFLKKEGITNVEIRIDNGRLEVRVEGGTERLKRFLEELRQKLEKKGYTVDIKIE\" #@param {type:\"string\"}\n",
+ "\n",
+ "#@markdown ---\n",
+ "#@markdown ###**Advanced Options**\n",
+ "num_recycles = 3 #@param [\"0\", \"1\", \"2\", \"3\", \"6\", \"12\"] {type:\"raw\"}\n",
+ "get_LM_contacts = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "#@markdown **multimer options (experimental)**\n",
+ "#@markdown - use \"/\" to specify chainbreaks, (eg. sequence=\"AAA/AAA\")\n",
+ "#@markdown - for homo-oligomeric predictions, set copies > 1\n",
+ "\n",
+ "copies = 1 #@param {type:\"integer\"}\n",
+ "chain_linker = 25 #@param {type:\"number\"}\n",
+ "\n",
+ "#@markdown **sampling options (experimental)**\n",
+ "#@markdown - Samples are generated via random masking (defined by `masking_rate`)\n",
+ "#@markdown of input sequence (stochastic_mode=\"LM\") and/or via dropout within structure module (stochastic_mode=\"SM\").\n",
+ "samples = None #@param [\"None\", \"1\", \"4\", \"8\", \"16\", \"32\", \"64\"] {type:\"raw\"}\n",
+ "masking_rate = 0.15 #@param {type:\"number\"}\n",
+ "stochastic_mode = \"LM\" #@param [\"LM\", \"LM_SM\", \"SM\"]\n",
+ "\n",
+ "o = predict_esmfold(\n",
+ " model=model,\n",
+ " sequence=sequence,\n",
+ " jobname=jobname,\n",
+ " num_recycles=num_recycles,\n",
+ " get_LM_contacts=get_LM_contacts,\n",
+ " copies=copies,\n",
+ " chain_linker=chain_linker,\n",
+ " samples=samples,\n",
+ " masking_rate=masking_rate,\n",
+ " stochastic_mode=stochastic_mode)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "UJ8ufvGNZfeQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "tg7eFMC-TYRX"
+ },
+ "outputs": [],
+ "source": [
+ "#@title display (optional) {run: \"auto\"}\n",
+ "#@markdown Note: If samples selected, the model with max pTM is displayed.\n",
+ "import py3Dmol\n",
+ "\n",
+ "\n",
+ "pymol_color_list = [\"#33ff33\",\"#00ffff\",\"#ff33cc\",\"#ffff00\",\"#ff9999\",\"#e5e5e5\",\"#7f7fff\",\"#ff7f00\",\n",
+ " \"#7fff7f\",\"#199999\",\"#ff007f\",\"#ffdd5e\",\"#8c3f99\",\"#b2b2b2\",\"#007fff\",\"#c4b200\",\n",
+ " \"#8cb266\",\"#00bfbf\",\"#b27f7f\",\"#fcd1a5\",\"#ff7f7f\",\"#ffbfdd\",\"#7fffff\",\"#ffff7f\",\n",
+ " \"#00ff7f\",\"#337fcc\",\"#d8337f\",\"#bfff3f\",\"#ff7fff\",\"#d8d8ff\",\"#3fffbf\",\"#b78c4c\",\n",
+ " \"#339933\",\"#66b2b2\",\"#ba8c84\",\"#84bf00\",\"#b24c66\",\"#7f7f7f\",\"#3f3fa5\",\"#a5512b\"]\n",
+ "\n",
+ "def show_pdb(pdb_str, show_sidechains=False, show_mainchains=False,\n",
+ " color=\"pLDDT\", chains=None, vmin=50, vmax=90,\n",
+ " size=(800,480), hbondCutoff=4.0,\n",
+ " Ls=None,\n",
+ " animate=False):\n",
+ "\n",
+ " if chains is None:\n",
+ " chains = 1 if Ls is None else len(Ls)\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js', width=size[0], height=size[1])\n",
+ " if animate:\n",
+ " view.addModelsAsFrames(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " else:\n",
+ " view.addModel(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " if color == \"pLDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':vmin,'max':vmax}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.zoomTo()\n",
+ " if animate: view.animate()\n",
+ " return view\n",
+ "\n",
+ "color = \"confidence\" #@param [\"confidence\", \"rainbow\", \"chain\"]\n",
+ "if color == \"confidence\": color = \"pLDDT\"\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "show_pdb(o[\"pdb_str\"], color=color,\n",
+ " show_sidechains=show_sidechains,\n",
+ " show_mainchains=show_mainchains,\n",
+ " Ls=o[\"lengths\"]).show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "hkiKtX43voI-"
+ },
+ "outputs": [],
+ "source": [
+ "#@title plot confidence (optional)\n",
+ "#@markdown Note: If samples selected, the model with max pTM is displayed.\n",
+ "dpi = 100 #@param {type:\"integer\"}\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "def plot_ticks(Ls):\n",
+ " Ln = sum(Ls)\n",
+ " L_prev = 0\n",
+ " for L_i in Ls[:-1]:\n",
+ " L = L_prev + L_i\n",
+ " L_prev += L_i\n",
+ " plt.plot([0,Ln],[L,L],color=\"black\")\n",
+ " plt.plot([L,L],[0,Ln],color=\"black\")\n",
+ " ticks = np.cumsum([0]+Ls)\n",
+ " ticks = (ticks[1:] + ticks[:-1])/2\n",
+ " plt.yticks(ticks,alphabet_list[:len(ticks)])\n",
+ "\n",
+ "def plot_confidence(output, Ls=None, dpi=100):\n",
+ " O = parse_output(output)\n",
+ " if \"lm_contacts\" in O:\n",
+ " plt.figure(figsize=(20,4), dpi=dpi)\n",
+ " plt.subplot(1,4,1)\n",
+ " else:\n",
+ " plt.figure(figsize=(15,4), dpi=dpi)\n",
+ " plt.subplot(1,3,1)\n",
+ "\n",
+ " plt.title('Predicted lDDT')\n",
+ " plt.plot(O[\"plddt\"])\n",
+ " if Ls is not None:\n",
+ " L_prev = 0\n",
+ " for L_i in Ls[:-1]:\n",
+ " L = L_prev + L_i\n",
+ " L_prev += L_i\n",
+ " plt.plot([L,L],[0,100],color=\"black\")\n",
+ " plt.xlim(0,O[\"plddt\"].shape[0])\n",
+ " plt.ylim(0,100)\n",
+ " plt.ylabel('plDDT')\n",
+ " plt.xlabel('position')\n",
+ " plt.subplot(1,4 if \"lm_contacts\" in O else 3,2)\n",
+ "\n",
+ " plt.title('Predicted Aligned Error')\n",
+ " Ln = O[\"pae\"].shape[0]\n",
+ " plt.imshow(O[\"pae\"],cmap=\"bwr\",vmin=0,vmax=30,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " plt.colorbar()\n",
+ " plt.xlabel('Scored residue')\n",
+ " plt.ylabel('Aligned residue')\n",
+ "\n",
+ " if \"lm_contacts\" in O:\n",
+ " plt.subplot(1,4,3)\n",
+ " plt.title(\"contacts from LM\")\n",
+ " plt.imshow(O[\"lm_contacts\"],cmap=\"Greys\",vmin=0,vmax=1,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " plt.subplot(1,4,4)\n",
+ " else:\n",
+ " plt.subplot(1,3,3)\n",
+ " plt.title(\"contacts from Structure Module\")\n",
+ " plt.imshow(O[\"sm_contacts\"],cmap=\"Greys\",vmin=0,vmax=1,extent=(0, Ln, Ln, 0))\n",
+ " if Ls is not None and len(Ls) > 1: plot_ticks(Ls)\n",
+ " return plt\n",
+ "\n",
+ "plot_confidence(o[\"output\"], Ls=o[\"lengths\"], dpi=dpi)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title download predictions\n",
+ "from google.colab import files\n",
+ "os.system(f\"zip {o['dir']}.zip {o['dir']}/*\")\n",
+ "files.download(f\"{o['dir']}.zip\")"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "AVn1z6H9o7GT"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title animate outputs (optional)\n",
+ "#@markdown if more than one sample generated\n",
+ "import os\n",
+ "if not os.path.isdir(\"colabfold\"):\n",
+ " os.system(\"git clone https://github.com/sokrypton/ColabFold.git\")\n",
+ "import ColabFold.beta.colabfold as cf\n",
+ "\n",
+ "dpi = 100#@param {type:\"integer\"}\n",
+ "color_by_plddt = True #@param {type:\"boolean\"}\n",
+ "use_pca = True\n",
+ "cycle = True\n",
+ "\n",
+ "import matplotlib\n",
+ "from matplotlib import animation\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.decomposition import PCA\n",
+ "\n",
+ "def mk_animation(xyz, labels, plddt, ref=0, Ls=None, line_w=2.0, dpi=100,color_by_plddt=False):\n",
+ "\n",
+ " def ca_align_to_last(positions, ref):\n",
+ " def align(P, Q):\n",
+ " if Ls is None or len(Ls) == 1:\n",
+ " P_,Q_ = P,Q\n",
+ " else:\n",
+ " # align relative to first chain\n",
+ " P_,Q_ = P[:Ls[0]],Q[:Ls[0]]\n",
+ " p = P_ - P_.mean(0,keepdims=True)\n",
+ " q = Q_ - Q_.mean(0,keepdims=True)\n",
+ " return ((P - P_.mean(0,keepdims=True)) @ cf.kabsch(p,q)) + Q_.mean(0,keepdims=True)\n",
+ "\n",
+ " pos = positions[ref] - positions[ref].mean(0,keepdims=True)\n",
+ " best_2D_view = pos @ cf.kabsch(pos,pos,return_v=True)\n",
+ "\n",
+ " new_positions = []\n",
+ " for i in range(len(positions)):\n",
+ " new_positions.append(align(positions[i],best_2D_view))\n",
+ " return np.asarray(new_positions)\n",
+ "\n",
+ " # align to reference\n",
+ " pos = ca_align_to_last(xyz, ref)\n",
+ "\n",
+ " fig, (ax1) = plt.subplots(1)\n",
+ " fig.set_figwidth(5)\n",
+ " fig.set_figheight(5)\n",
+ " fig.set_dpi(dpi)\n",
+ "\n",
+ " xy_min = pos[...,:2].min() - 1\n",
+ " xy_max = pos[...,:2].max() + 1\n",
+ "\n",
+ " for ax in [ax1]:\n",
+ " ax.set_xlim(xy_min, xy_max)\n",
+ " ax.set_ylim(xy_min, xy_max)\n",
+ " ax.axis(False)\n",
+ "\n",
+ " ims=[]\n",
+ " for l,pos_,plddt_ in zip(labels,pos,plddt):\n",
+ " if color_by_plddt:\n",
+ " img = cf.plot_pseudo_3D(pos_, c=plddt_, cmin=50, cmax=90, line_w=line_w, ax=ax1)\n",
+ " elif Ls is None or len(Ls) == 1:\n",
+ " img = cf.plot_pseudo_3D(pos_, ax=ax1, line_w=line_w)\n",
+ " else:\n",
+ " c = np.concatenate([[n]*L for n,L in enumerate(Ls)])\n",
+ " img = cf.plot_pseudo_3D(pos_, c=c, cmap=cf.pymol_cmap, cmin=0, cmax=39, line_w=line_w, ax=ax1)\n",
+ " ims.append([cf.add_text(f\"{l}\", ax1),img])\n",
+ "\n",
+ " ani = animation.ArtistAnimation(fig, ims, blit=True, interval=120)\n",
+ " plt.close()\n",
+ " return ani.to_html5_video()\n",
+ "\n",
+ "labels = np.array([f\"seed:{x}\" for x in range(len(o[\"traj\"]))])\n",
+ "pos = np.array([x[\"xyz\"] for x in o[\"traj\"]])\n",
+ "plddt = np.array([x[\"plddt\"] for x in o[\"traj\"]])\n",
+ "if use_pca and pos.shape[0] > 1:\n",
+ " pos_ca = pos\n",
+ " if o[\"lengths\"] is not None and len(o[\"lengths\"]) > 1:\n",
+ " pos_ca = pos_ca[:,:o[\"lengths\"][0]]\n",
+ " i,j = np.triu_indices(pos_ca.shape[1],k=1)\n",
+ " pos_ca_dm = np.sqrt(np.square(pos_ca[:,None,:,:] - pos_ca[:,:,None]).sum(-1))[:,i,j]\n",
+ " pc = PCA(1).fit_transform(pos_ca_dm)[:,0].argsort()\n",
+ " if cycle:\n",
+ " pc = np.append(pc,pc[1:-1][::-1])\n",
+ " pos = pos[pc]\n",
+ " labels = labels[pc]\n",
+ " plddt = plddt[pc]\n",
+ "HTML(mk_animation(pos, labels, plddt, Ls=o[\"lengths\"], dpi=dpi, color_by_plddt=color_by_plddt))"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "NY8H_iM5WFUu"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "gpuClass": "standard",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/data/beta/ESMFold_api.ipynb b/data/beta/ESMFold_api.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..4f827842bb29eecee2088c082add02f4275529c6
--- /dev/null
+++ b/data/beta/ESMFold_api.ipynb
@@ -0,0 +1,156 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "authorship_tag": "ABX9TyOTvNvYm0TYMGMVWT4fM7rz",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#**ESMFold API**\n",
+ "for more details see: [Github](https://github.com/facebookresearch/esm/tree/main/esm), [Preprint](https://www.biorxiv.org/content/10.1101/2022.07.20.500902v1)\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "\n",
+ "#### **Limitations**\n",
+ "- max total length=400\n",
+ "- for lengths > 400, try our [colab notebook](https://colab.research.google.com/github/sokrypton/ColabFold/blob/main/ESMFold.ipynb)\n",
+ "---"
+ ],
+ "metadata": {
+ "id": "v2jU2RLyacXQ"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "M8p9x4xCXCrw"
+ },
+ "outputs": [],
+ "source": [
+ "#@title run **ESMFold**\n",
+ "import os, time, re, requests\n",
+ "if not os.path.isfile(\"colabfold.py\"):\n",
+ " os.system(\"pip -q install pyppeteer nest_asyncio\")\n",
+ " import asyncio\n",
+ " import nest_asyncio\n",
+ " from pyppeteer import launch\n",
+ " import base64\n",
+ "\n",
+ " # Apply nest_asyncio to enable nested event loops\n",
+ " nest_asyncio.apply()\n",
+ "\n",
+ " async def fetch_blob_content(page, blob_url):\n",
+ " blob_to_base64 = \"\"\"\n",
+ " async (blobUrl) => {\n",
+ " const blob = await fetch(blobUrl).then(r => r.blob());\n",
+ " return new Promise((resolve) => {\n",
+ " const reader = new FileReader();\n",
+ " reader.onloadend = () => resolve(reader.result);\n",
+ " reader.readAsDataURL(blob);\n",
+ " });\n",
+ " }\n",
+ " \"\"\"\n",
+ " base64_data = await page.evaluate(blob_to_base64, blob_url)\n",
+ " _, encoded = base64_data.split(',', 1)\n",
+ " return base64.b64decode(encoded)\n",
+ "\n",
+ " async def extract_pdb_file_download_link_and_content(url):\n",
+ " browser = await launch(headless=True, args=['--no-sandbox', '--disable-setuid-sandbox'])\n",
+ " page = await browser.newPage()\n",
+ " await page.goto(url, {'waitUntil': 'networkidle0'})\n",
+ " elements = await page.querySelectorAll('a.btn.bg-purple')\n",
+ " for element in elements:\n",
+ " href = await page.evaluate('(element) => element.getAttribute(\"href\")', element)\n",
+ " if 'blob:https://esmatlas.com/' in href:\n",
+ " content = await fetch_blob_content(page, href)\n",
+ " await browser.close()\n",
+ " return href, content\n",
+ " await browser.close()\n",
+ " return \"No PDB file link found.\", None\n",
+ "\n",
+ " def esmfold_api(sequence):\n",
+ " url = f'https://esmatlas.com/resources/fold/result?fasta_header=%3Eunnamed&sequence={sequence}'\n",
+ " result = asyncio.get_event_loop().run_until_complete(extract_pdb_file_download_link_and_content(url))\n",
+ " if result[1]:\n",
+ " pdb_str = result[1].decode('utf-8')\n",
+ " return pdb_str\n",
+ " else:\n",
+ " return \"Failed to retrieve PDB content.\"\n",
+ "\n",
+ " os.system(\"pip -q install py3Dmol\")\n",
+ " os.system(\"wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\")\n",
+ " os.system(\"mkdir -p tmp\")\n",
+ "\n",
+ "import colabfold as cf\n",
+ "\n",
+ "\n",
+ "sequence = \"GWSTELEKHREELKEFLKKEGITNVEIRIDNGRLEVRVEGGTERLKRFLEELRQKLEKKGYTVDIKIE\" #@param {type:\"string\"}\n",
+ "sequence = re.sub(\"[^A-Z]\", \"\", sequence.upper())\n",
+ "#assert len(sequence) <= 400, \"error: max length supported is 400\"\n",
+ "hash = cf.get_hash(sequence)[:5]\n",
+ "pdb_filename = f\"tmp/prediction_{hash}.pdb\"\n",
+ "if not os.path.isfile(pdb_filename):\n",
+ " pdb_str = esmfold_api(sequence)\n",
+ " with open(pdb_filename,\"w\") as out:\n",
+ " out.write(pdb_str)\n",
+ "\n",
+ "color = \"confidence\" #@param [\"confidence\", \"rainbow\"]\n",
+ "if color == \"confidence\": color = \"lDDT\"\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "v = cf.show_pdb(pdb_filename,\n",
+ " show_sidechains,\n",
+ " show_mainchains, color,\n",
+ " color_HP=True,\n",
+ " size=(800,480),\n",
+ " vmin=0.5, vmax=0.9)\n",
+ "v.setHoverable({}, True,\n",
+ " '''function(atom,viewer,event,container){if(!atom.label){atom.label=viewer.addLabel(\" \"+atom.resn+\":\"+atom.resi,{position:atom,backgroundColor:'mintcream',fontColor:'black'});}}''',\n",
+ " '''function(atom,viewer){if(atom.label){viewer.removeLabel(atom.label);delete atom.label;}}''')\n",
+ "v.show()\n",
+ "if color == \"lDDT\":\n",
+ " cf.plot_plddt_legend().show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title download prediction\n",
+ "from google.colab import files\n",
+ "files.download(pdb_filename)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "fcR0YV4IaRpU"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/RoseTTAFold.ipynb b/data/beta/RoseTTAFold.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..53b3415523181da28b0bb16d2a7087d084f3e35d
--- /dev/null
+++ b/data/beta/RoseTTAFold.ipynb
@@ -0,0 +1,388 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "RoseTTAFold.ipynb",
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "74RP4ByMFXHR"
+ },
+ "source": [
+ "# RoseTTAFold w/ PyRosetta\n",
+ "\n",
+ "**Limitations**\n",
+ "- This notebook disables a few aspects (templates) of the full rosettafold pipeline.\n",
+ "- For best resuls use the [full pipeline](https://github.com/RosettaCommons/RoseTTAFold) or [Robetta webserver](https://robetta.bakerlab.org/)!\n",
+ "- For a typical Google-Colab session, with a `16G-GPU`, the max total length is **700 residues**. Sometimes a `12G-GPU` is assigned, in which case the max length is lower.\n",
+ "\n",
+ "For other related notebooks see [ColabFold](https://github.com/sokrypton/ColabFold)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "8v06TAo9ZaGH",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title ##Install and import libraries\n",
+ "if \"PAPERMILL_INPUT_PATH\" not in dir():\n",
+ " #@markdown This step will take 2+ mins (6min PyRosetta, 2min RoseTTAFold)\n",
+ " use_pyrosetta = False #@param {type:\"boolean\"}\n",
+ " #@markdown - Use PyRosetta for structure prediction. To do so you'll need to get a [PyRosetta License](https://els2.comotion.uw.edu/product/pyrosetta) (free for academic use).\n",
+ " #@markdown Once you obtain license, enter the username and password below.\n",
+ " username = '' #@param {type:\"string\"}\n",
+ " username.strip().lower()\n",
+ " password = '' #@param {type:\"string\"}\n",
+ "\n",
+ "import os\n",
+ "import subprocess\n",
+ "import hashlib\n",
+ "\n",
+ "import sys\n",
+ "from IPython.utils import io\n",
+ "try:\n",
+ " from google.colab import files\n",
+ "except:\n",
+ " from IPython.core.magic import register_line_magic\n",
+ " @register_line_magic\n",
+ " def tensorflow_version(line):\n",
+ " pass\n",
+ " pass\n",
+ "\n",
+ "if use_pyrosetta:\n",
+ " # Thanks Matteo Ferla for password check\n",
+ " hashed_username = hashlib.sha256(username.encode()).hexdigest()\n",
+ " hashed_password = hashlib.sha256(password.encode()).hexdigest()\n",
+ " expected_hashed_username = 'cf6f296b8145262b22721e52e2edec13ce57af8c6fc990c8ae1a4aa3e50ae40e'\n",
+ " expected_hashed_password = '45066dd976d8bf0c05dc8dd4d58727945c3437e6eb361ba9870097968db7a0da'\n",
+ " msg = 'Error: username or password is incorrect.'\n",
+ " assert hashed_username == expected_hashed_username, msg\n",
+ " assert hashed_password == expected_hashed_password, msg\n",
+ "\n",
+ " dist = subprocess.check_output(['lsb_release', '-is']).strip()\n",
+ " if dist == \"Ubuntu\":\n",
+ " dist = \"ubuntu\"\n",
+ " else:\n",
+ " dist = \"linux\"\n",
+ " pyrosetta_path = f\"PyRosetta4.Release.python37.{dist}.release-306\"\n",
+ " if not os.path.isdir(pyrosetta_path):\n",
+ " print(\"installing pyRosetta - 6 mins\")\n",
+ " with io.capture_output() as captured:\n",
+ " !wget --show-progress --user {username} --password {password} https://graylab.jhu.edu/download/PyRosetta4/archive/release/PyRosetta4.Release.python37.{dist}/{pyrosetta_path}.tar.bz2 -O - | tar -xj\n",
+ " !pip install -e {pyrosetta_path}/setup/\n",
+ "\n",
+ "if not os.path.isdir(\"RoseTTAFold\"):\n",
+ " print(\"installing RoseTTAFold - 2 mins\")\n",
+ " with io.capture_output() as captured:\n",
+ " # extra functionality\n",
+ " !wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\n",
+ "\n",
+ " # download model\n",
+ " !git clone https://github.com/RosettaCommons/RoseTTAFold.git\n",
+ " !wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/RoseTTAFold__network__Refine_module.patch\n",
+ " !patch -u RoseTTAFold/network/Refine_module.py -i RoseTTAFold__network__Refine_module.patch\n",
+ "\n",
+ " # download model params\n",
+ " !wget -qnc https://files.ipd.uw.edu/pub/RoseTTAFold/weights.tar.gz\n",
+ " !tar -xf weights.tar.gz\n",
+ " !rm weights.tar.gz\n",
+ "\n",
+ " # download scwrl4 (for adding sidechains)\n",
+ " # http://dunbrack.fccc.edu/SCWRL3.php\n",
+ " # Thanks Roland Dunbrack!\n",
+ " !wget -qnc https://files.ipd.uw.edu/krypton/TrRosetta/scwrl4.zip\n",
+ " !unzip -qqo scwrl4.zip\n",
+ "\n",
+ " # install libraries\n",
+ " !pip install -q dgl-cu113 -f https://data.dgl.ai/wheels/repo.html\n",
+ " !pip install -q torch-scatter -f https://pytorch-geometric.com/whl/torch-1.11.0+cu113.html\n",
+ " !pip install -q torch-sparse -f https://pytorch-geometric.com/whl/torch-1.11.0+cu113.html\n",
+ " !pip install -q torch-geometric\n",
+ " !pip install -q py3Dmol\n",
+ "\n",
+ " !wget https://openstructure.org/static/lddt-linux.zip -O lddt.zip\n",
+ " !unzip -d ./RoseTTAFold/lddt -j lddt.zip\n",
+ "\n",
+ "with io.capture_output() as captured:\n",
+ " sys.path.append('./RoseTTAFold/network')\n",
+ " import predict_e2e, predict_pyRosetta\n",
+ " from parsers import parse_a3m\n",
+ " \n",
+ "import colabfold as cf\n",
+ "import py3Dmol\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "def get_bfactor(pdb_filename):\n",
+ " bfac = []\n",
+ " for line in open(pdb_filename,\"r\"):\n",
+ " if line[:4] == \"ATOM\":\n",
+ " bfac.append(float(line[60:66]))\n",
+ " return np.array(bfac)\n",
+ "\n",
+ "def set_bfactor(pdb_filename, bfac):\n",
+ " I = open(pdb_filename,\"r\").readlines()\n",
+ " O = open(pdb_filename,\"w\")\n",
+ " for line in I:\n",
+ " if line[0:6] == \"ATOM \":\n",
+ " seq_id = int(line[22:26].strip()) - 1\n",
+ " O.write(f\"{line[:60]}{bfac[seq_id]:6.2f}{line[66:]}\")\n",
+ " O.close() \n",
+ "\n",
+ "def do_scwrl(inputs, outputs, exe=\"./scwrl4/Scwrl4\"):\n",
+ " subprocess.run([exe,\"-i\",inputs,\"-o\",outputs,\"-h\"],\n",
+ " stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)\n",
+ " bfact = get_bfactor(inputs)\n",
+ " set_bfactor(outputs, bfact)\n",
+ " return bfact"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "YWe2OSU59iKD",
+ "cellView": "form"
+ },
+ "source": [
+ "#@markdown ##Input Sequence\n",
+ "if \"PAPERMILL_INPUT_PATH\" not in dir():\n",
+ " sequence = \"PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK\" #@param {type:\"string\"}\n",
+ " jobname = \"test\" #@param {type:\"string\"}\n",
+ "\n",
+ "sequence = sequence.translate(str.maketrans('', '', ' \\n\\t')).upper()\n",
+ "jobname = jobname+\"_\"+cf.get_hash(sequence)[:5]"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "_nTsyKtQxjO8",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Search against genetic databases\n",
+ "if \"PAPERMILL_INPUT_PATH\" not in dir():\n",
+ " #@markdown ---\n",
+ " msa_method = \"mmseqs2\" #@param [\"mmseqs2\",\"single_sequence\",\"custom_a3m\"]\n",
+ " #@markdown - `mmseqs2` - FAST method from [ColabFold](https://github.com/sokrypton/ColabFold)\n",
+ " #@markdown - `single_sequence` - use single sequence input (not recommended, unless a *denovo* design and you dont expect to find any homologous sequences)\n",
+ " #@markdown - `custom_a3m` Upload custom MSA (a3m format)\n",
+ "\n",
+ "# tmp directory\n",
+ "prefix = cf.get_hash(sequence)\n",
+ "os.makedirs('tmp', exist_ok=True)\n",
+ "prefix = os.path.join('tmp',prefix)\n",
+ "\n",
+ "os.makedirs(jobname, exist_ok=True)\n",
+ "\n",
+ "\n",
+ "if msa_method == \"mmseqs2\":\n",
+ " if \"PAPERMILL_INPUT_PATH\" not in dir():\n",
+ " host_url=\"https://a3m.mmseqs.com\"\n",
+ " a3m_lines = cf.run_mmseqs2(sequence, prefix, filter=True, host_url=host_url)\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(a3m_lines)\n",
+ "\n",
+ "elif msa_method == \"single_sequence\":\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(f\">{jobname}\\n{sequence}\\n\")\n",
+ "\n",
+ "elif msa_method == \"custom_a3m\":\n",
+ " if \"PAPERMILL_INPUT_PATH\" not in dir():\n",
+ " print(\"upload custom a3m\")\n",
+ " msa_dict = files.upload()\n",
+ " lines = msa_dict[list(msa_dict.keys())[0]].decode().splitlines()\n",
+ " a3m_lines = []\n",
+ " for line in lines:\n",
+ " line = line.replace(\"\\x00\",\"\")\n",
+ " if len(line) > 0 and not line.startswith('#'):\n",
+ " a3m_lines.append(line)\n",
+ " with open(f\"{jobname}/msa.a3m\",\"w\") as a3m:\n",
+ " a3m.write(\"\\n\".join(a3m_lines))\n",
+ " else:\n",
+ " import shutil\n",
+ " shutil.copy(a3m_file, f\"{jobname}/msa.a3m\")\n",
+ "\n",
+ "msa_all = parse_a3m(f\"{jobname}/msa.a3m\")\n",
+ "msa_arr = np.unique(msa_all,axis=0)\n",
+ "total_msa_size = len(msa_arr)\n",
+ "if msa_method == \"mmseqs2\":\n",
+ " print(f'\\n{total_msa_size} Sequences Found in Total (after filtering)\\n')\n",
+ "else:\n",
+ " print(f'\\n{total_msa_size} Sequences Found in Total\\n')\n",
+ "\n",
+ "if total_msa_size > 1:\n",
+ " plt.figure(figsize=(8,5),dpi=100)\n",
+ " plt.title(\"Sequence coverage\")\n",
+ " seqid = (msa_all[0] == msa_arr).mean(-1)\n",
+ " seqid_sort = seqid.argsort()\n",
+ " non_gaps = (msa_arr != 20).astype(float)\n",
+ " non_gaps[non_gaps == 0] = np.nan\n",
+ " plt.imshow(non_gaps[seqid_sort]*seqid[seqid_sort,None],\n",
+ " interpolation='nearest', aspect='auto',\n",
+ " cmap=\"rainbow_r\", vmin=0, vmax=1, origin='lower',\n",
+ " extent=(0, msa_arr.shape[1], 0, msa_arr.shape[0]))\n",
+ " plt.plot((msa_arr != 20).sum(0), color='black')\n",
+ " plt.xlim(0,msa_arr.shape[1])\n",
+ " plt.ylim(0,msa_arr.shape[0])\n",
+ " plt.colorbar(label=\"Sequence identity to query\",)\n",
+ " plt.xlabel(\"Positions\")\n",
+ " plt.ylabel(\"Sequences\")\n",
+ " plt.savefig(f\"{jobname}/msa_coverage.png\", bbox_inches = 'tight')\n",
+ " plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "14-q4hv59ast",
+ "cellView": "form"
+ },
+ "source": [
+ "%tensorflow_version 1.x\n",
+ "#@title ## Run RoseTTAFold\n",
+ "# load model\n",
+ "if \"rosettafold\" not in dir():\n",
+ " if use_pyrosetta:\n",
+ " rosettafold = predict_pyRosetta.Predictor(model_dir=\"weights\")\n",
+ " else:\n",
+ " rosettafold = predict_e2e.Predictor(model_dir=\"weights\")\n",
+ "\n",
+ "# make prediction using model\n",
+ "if use_pyrosetta:\n",
+ " if not os.path.isfile(f\"{jobname}/pred.npz\"):\n",
+ " print(\"running RoseTTAFold\")\n",
+ " rosettafold.predict(f\"{jobname}/msa.a3m\",f\"{jobname}/pred\")\n",
+ "else:\n",
+ " if not os.path.isfile(f\"{jobname}/pred.pdb\"):\n",
+ " print(\"running RoseTTAFold\")\n",
+ " rosettafold.predict(f\"{jobname}/msa.a3m\",f\"{jobname}/pred\")\n",
+ "\n",
+ "if not os.path.isfile(f\"{jobname}/pred.fasta\"):\n",
+ " with open(f\"{jobname}/pred.fasta\",\"w\") as out:\n",
+ " out.write(f\">pred\\n{sequence}\\n\")\n",
+ "\n",
+ "if use_pyrosetta:\n",
+ " CPU = max(1, len(os.sched_getaffinity(0)))\n",
+ " pyrosetta_script = \"./RoseTTAFold/folding/RosettaTR.py\"\n",
+ " if not os.path.isfile(f\"{jobname}/model/model_1.crderr.pdb\"):\n",
+ " print(\"running PyRosetta\")\n",
+ " with open(f\"{jobname}/job_list\",\"w\") as job_list:\n",
+ " for m in [0,1,2]:\n",
+ " for p in [0.05,0.15,0.25,0.35,0.45]:\n",
+ " pdb_out = f\"{jobname}/model_{m}_{p}.pdb\"\n",
+ " opt = f\"--roll -r 3 -pd {p} -m {m} -sg 7,3\"\n",
+ " if not os.path.isfile(pdb_out):\n",
+ " job_list.write(f\"python -u {pyrosetta_script} {opt} {jobname}/pred.npz {jobname}/pred.fasta {pdb_out}\\n\")\n",
+ " os.system(f\"cat {jobname}/job_list | tr '\\\\n' '\\\\0' | xargs -0 -L 1 -P {CPU} -I % sh -c '%'\")\n",
+ " \n",
+ " print(\"ranking models using DAN\")\n",
+ " dan_script = \"./RoseTTAFold/DAN-msa/ErrorPredictorMSA.py\"\n",
+ " dan_pick_script = \"./RoseTTAFold/DAN-msa/pick_final_models.div.py\"\n",
+ " os.system(f\"python {dan_script} --roll -p {CPU} {jobname}/pred.npz {jobname} {jobname}\")\n",
+ " os.system(f\"python {dan_pick_script} {jobname} {jobname}/model {CPU}\")\n",
+ " \n",
+ " plddt = get_bfactor(f\"{jobname}/model/model_1.crderr.pdb\")\n",
+ " \n",
+ "else:\n",
+ " # pack sidechains using Scwrl4\n",
+ " plddt = do_scwrl(f\"{jobname}/pred.pdb\",f\"{jobname}/pred.scwrl.pdb\")\n",
+ "\n",
+ "print(f\"Predicted LDDT: {plddt.mean()}\")\n",
+ "plt.figure(figsize=(8,5),dpi=100)\n",
+ "plt.plot(plddt)\n",
+ "plt.xlabel(\"positions\")\n",
+ "plt.ylabel(\"plddt\")\n",
+ "plt.ylim(0,1)\n",
+ "plt.savefig(f\"{jobname}/plddt.png\", bbox_inches = 'tight')\n",
+ "plt.show()"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "qPhmF8SZr1k8",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Display 3D structure {run: \"auto\"}\n",
+ "color = \"lDDT\" #@param [\"chain\", \"lDDT\", \"rainbow\"]\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "if use_pyrosetta:\n",
+ " cf.show_pdb(f\"{jobname}/model/model_1.crderr.pdb\", show_sidechains, show_mainchains, color, chains=1, vmin=0.5, vmax=0.9).show()\n",
+ "else:\n",
+ " cf.show_pdb(f\"{jobname}/pred.scwrl.pdb\", show_sidechains, show_mainchains, color, chains=1, vmin=0.5, vmax=0.9).show()\n",
+ "\n",
+ "if color == \"lDDT\": cf.plot_plddt_legend().show() "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "j0RhMLHKHf8d",
+ "cellView": "form"
+ },
+ "source": [
+ "#@title Download prediction\n",
+ "\n",
+ "#@markdown Once this cell has been executed, a zip-archive with \n",
+ "#@markdown the obtained prediction will be automatically downloaded \n",
+ "#@markdown to your computer.\n",
+ "\n",
+ "# add settings file\n",
+ "settings_path = f\"{jobname}/settings.txt\"\n",
+ "with open(settings_path, \"w\") as text_file:\n",
+ " text_file.write(f\"method=RoseTTAFold\\n\")\n",
+ " text_file.write(f\"sequence={sequence}\\n\")\n",
+ " text_file.write(f\"msa_method={msa_method}\\n\")\n",
+ " text_file.write(f\"use_templates=False\\n\")\n",
+ "\n",
+ "# --- Download the predictions ---\n",
+ "!zip -q -r {jobname}.zip {jobname}\n",
+ "try:\n",
+ " files.download(f'{jobname}.zip')\n",
+ "except:\n",
+ " pass\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/data/beta/RoseTTAFold__network__Refine_module.patch b/data/beta/RoseTTAFold__network__Refine_module.patch
new file mode 100644
index 0000000000000000000000000000000000000000..4d7e7ce7e5aab36830c17b135268a9784a6c3647
--- /dev/null
+++ b/data/beta/RoseTTAFold__network__Refine_module.patch
@@ -0,0 +1,106 @@
+--- Refine_module_old.py 2021-08-04 07:49:26.000000000 -0400
++++ Refine_module.py 2021-08-04 07:46:27.000000000 -0400
+@@ -129,47 +129,61 @@
+ self.norm_state = LayerNorm(SE3_param['l0_out_features'])
+ self.pred_lddt = nn.Linear(SE3_param['l0_out_features'], 1)
+
+- def forward(self, node, edge, seq1hot, idx, use_transf_checkpoint=False, eps=1e-4):
++ def forward(self, node, edge, seq1hot, idx, use_transf_checkpoint=False, eps=1e-4,
++ mirror_mode="serial"):
++
++ def run(xyz, state, node, edge, idx, seq1hot):
++ best_xyz = xyz
++ best_lddt = torch.zeros((xyz.shape[0], xyz.shape[1], 1), device=xyz.device)
++ prev_lddt = 0.0
++ no_impr = 0
++ no_impr_best = 0
++ for i_iter in range(200):
++ for i_m in range(self.n_module):
++ if use_transf_checkpoint:
++ xyz, state = checkpoint.checkpoint(create_custom_forward(self.refine_net[i_m], top_k=64), node.float(), edge.float(), xyz.detach().float(), state.float(), seq1hot, idx)
++ else:
++ xyz, state = self.refine_net[i_m](node.float(), edge.float(), xyz.detach().float(), state.float(), seq1hot, idx, top_k=64)
++ #
++ lddt = self.pred_lddt(self.norm_state(state))
++ lddt = torch.clamp(lddt, 0.0, 1.0)[...,0]
++ print (f"SE(3) iteration {i_iter} {lddt.mean(-1).cpu().numpy()}")
++ if lddt.mean(-1).max() <= prev_lddt+eps:
++ no_impr += 1
++ else:
++ no_impr = 0
++ if lddt.mean(-1).max() <= best_lddt.mean(-1).max()+eps:
++ no_impr_best += 1
++ else:
++ no_impr_best = 0
++ if no_impr > 10 or no_impr_best > 20:
++ break
++ if lddt.mean(-1).max() > best_lddt.mean(-1).max():
++ best_lddt = lddt
++ best_xyz = xyz
++ prev_lddt = lddt.mean(-1).max()
++
++ return best_xyz, best_lddt
++
+ edge = self.proj_edge(edge)
+-
+ xyz, state = self.regen_net(seq1hot, idx, node, edge)
+-
+- # DOUBLE IT w/ Mirror images
+- xyz = torch.cat([xyz, xyz*torch.tensor([1,1,-1], dtype=xyz.dtype, device=xyz.device)])
+- state = torch.cat([state, state])
+- node = torch.cat([node, node])
+- edge = torch.cat([edge, edge])
+- idx = torch.cat([idx, idx])
+- seq1hot = torch.cat([seq1hot, seq1hot])
+
+- best_xyz = xyz
+- best_lddt = torch.zeros((xyz.shape[0], xyz.shape[1], 1), device=xyz.device)
+- prev_lddt = 0.0
+- no_impr = 0
+- no_impr_best = 0
+- for i_iter in range(200):
+- for i_m in range(self.n_module):
+- if use_transf_checkpoint:
+- xyz, state = checkpoint.checkpoint(create_custom_forward(self.refine_net[i_m], top_k=64), node.float(), edge.float(), xyz.detach().float(), state.float(), seq1hot, idx)
+- else:
+- xyz, state = self.refine_net[i_m](node.float(), edge.float(), xyz.detach().float(), state.float(), seq1hot, idx, top_k=64)
+- #
+- lddt = self.pred_lddt(self.norm_state(state))
+- lddt = torch.clamp(lddt, 0.0, 1.0)[...,0]
+- print (f"SE(3) iteration {i_iter} {lddt.mean(-1).cpu().numpy()}")
+- if lddt.mean(-1).max() <= prev_lddt+eps:
+- no_impr += 1
+- else:
+- no_impr = 0
+- if lddt.mean(-1).max() <= best_lddt.mean(-1).max()+eps:
+- no_impr_best += 1
+- else:
+- no_impr_best = 0
+- if no_impr > 10 or no_impr_best > 20:
+- break
+- if lddt.mean(-1).max() > best_lddt.mean(-1).max():
+- best_lddt = lddt
+- best_xyz = xyz
+- prev_lddt = lddt.mean(-1).max()
+- pick = best_lddt.mean(-1).argmax()
+- return best_xyz[pick][None], best_lddt[pick][None]
++ # DOUBLE IT w/ Mirror images
++ if mirror_mode == "parallel":
++ xyz = torch.cat([xyz, xyz*torch.tensor([1,1,-1], dtype=xyz.dtype, device=xyz.device)])
++ state = torch.cat([state, state])
++ node = torch.cat([node, node])
++ edge = torch.cat([edge, edge])
++ idx = torch.cat([idx, idx])
++ seq1hot = torch.cat([seq1hot, seq1hot])
++ best_xyz, best_lddt = run(xyz, state, node, edge, idx, seq1hot)
++ pick = best_lddt.mean(-1).argmax()
++ return best_xyz[pick][None], best_lddt[pick][None]
++ else:
++ best_xyz_A, best_lddt_A = run(xyz, state, node, edge, idx, seq1hot)
++ xyz = xyz * torch.tensor([1,1,-1], dtype=xyz.dtype, device=xyz.device)
++ best_xyz_B, best_lddt_B = run(xyz, state, node, edge, idx, seq1hot)
++ if best_lddt_B.mean() > best_lddt_A.mean():
++ return best_xyz_B, best_lddt_B
++ else:
++ return best_xyz_A, best_lddt_A
+\ No newline at end of file
diff --git a/data/beta/RoseTTAFold_install.sh b/data/beta/RoseTTAFold_install.sh
new file mode 100644
index 0000000000000000000000000000000000000000..46a9a3ed672f96897499a81f22dd0ee40f0cd542
--- /dev/null
+++ b/data/beta/RoseTTAFold_install.sh
@@ -0,0 +1,5 @@
+#!/bin/sh -e
+conda create -n rosettafold -c conda-forge cudnn cudatoolkit==11.3.1 cudatoolkit-dev==11.3.1 python==3.7
+conda activate rosettafold
+pip install jupyter papermill matplotlib tensorflow-gpu==1.15
+pip install torch==1.10.0+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html
diff --git a/data/beta/RoseTTAFold_run.sh b/data/beta/RoseTTAFold_run.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8d1c848d9066f751f33410b8592b45d9130d7a84
--- /dev/null
+++ b/data/beta/RoseTTAFold_run.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -e
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+INPUT="$(readlink -f "$1")"
+shift
+OUTPUT="$(readlink -f "$2")"
+shift
+USERNAME="$3"
+shift
+PASSWORD="$4"
+shift
+unset CONDA_SHLVL
+eval "$(conda shell.bash hook)"
+conda activate rosettafold
+mkdir -p ${OUTPUT}
+HEADER="$(cat "$INPUT" | awk 'NR == 1 { print substr($1, 2); exit; }')"
+SEQUENCE="$(cat "$INPUT" | awk 'NR == 2 { print $1; exit; }')"
+if [ "${INPUT##*.}" = "a3m" ]; then
+ A3M_FILE="$INPUT"
+ MSA_METHOD=custom_a3m
+else
+ A3M_FILE=""
+ MSA_METHOD=mmseqs2
+fi
+PYROSETTA=True
+/usr/bin/time -v papermill "${SCRIPT_DIR}/RoseTTAFold.ipynb" "${OUTPUT}.ipynb" --inject-input-path -p use_pyrosetta "${PYROSETTA}" -p username "${USERNAME}" -p password "${PASSWORD}" -p jobname "$HEADER" -p sequence "$SEQUENCE" -p a3m_file "${A3M_FILE}" -p msa_method "${MSA_METHOD}" -p host_url "https://a3m.mmseqs.com" "$@" 2>&1 | tee "${OUTPUT}.log"
diff --git a/data/beta/alphafold_output_at_each_recycle.ipynb b/data/beta/alphafold_output_at_each_recycle.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..df64938026d1828b3a77a95f087dd68442deb955
--- /dev/null
+++ b/data/beta/alphafold_output_at_each_recycle.ipynb
@@ -0,0 +1,5576 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "alphafold_output_at_each_recycle.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "vJxiCSLc7IWD",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "a607d5f0-a41f-4e88-8f69-c32c0694512b"
+ },
+ "source": [
+ "%%bash\n",
+ "if [ ! -d alphafold ]; then\n",
+ " pip -q install biopython dm-haiku ml-collections py3Dmol\n",
+ "\n",
+ " # download model\n",
+ " git clone --quiet https://github.com/deepmind/alphafold.git\n",
+ " cd /content/alphafold\n",
+ " git checkout --quiet 1d43aaff941c84dc56311076b58795797e49107b\n",
+ " cd /content\n",
+ "\n",
+ " # apply patch to return model at each recycle step\n",
+ " wget -qnc https://raw.githubusercontent.com/sokrypton/af_tests/main/model.patch\n",
+ " wget -qnc https://raw.githubusercontent.com/sokrypton/af_tests/main/modules.patch\n",
+ " patch -u alphafold/alphafold/model/model.py -i model.patch\n",
+ " patch -u alphafold/alphafold/model/modules.py -i modules.patch\n",
+ "\n",
+ " # download model params (~1 min)\n",
+ " mkdir params\n",
+ " curl -fsSL https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar | tar x -C params\n",
+ "\n",
+ " # colabfold\n",
+ " wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/beta/colabfold.py\n",
+ "fi"
+ ],
+ "execution_count": 1,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "patching file alphafold/alphafold/model/model.py\n",
+ "patching file alphafold/alphafold/model/modules.py\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ptyikINV7TwY"
+ },
+ "source": [
+ "# import libraries\n",
+ "import os\n",
+ "import sys\n",
+ "sys.path.append('/content/alphafold')\n",
+ "\n",
+ "import numpy as np\n",
+ "import jax.numpy as jnp\n",
+ "\n",
+ "from alphafold.common import protein\n",
+ "from alphafold.data import pipeline\n",
+ "from alphafold.data import templates\n",
+ "from alphafold.model import data\n",
+ "from alphafold.model import config\n",
+ "from alphafold.model import model\n",
+ "\n",
+ "import colabfold as cf"
+ ],
+ "execution_count": 2,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Vv4mQRNO9onw"
+ },
+ "source": [
+ "# setup which model params to use\n",
+ "model_name = \"model_2_ptm\" # model we want to use\n",
+ "model_config = config.model_config(\"model_5_ptm\") # configure based on model that doesn't use templates\n",
+ "\n",
+ "model_config.model.num_recycle = 24\n",
+ "model_config.data.common.num_recycle = 24\n",
+ "\n",
+ "# since we'll be using single sequence input, setting size of MSA to 1\n",
+ "model_config.data.common.max_extra_msa = 1 # 5120\n",
+ "model_config.data.eval.max_msa_clusters = 1 # 512\n",
+ "\n",
+ "# setup model\n",
+ "model_params = data.get_model_haiku_params(model_name=model_name, data_dir=\".\")\n",
+ "model_runner = model.RunModel(model_config, model_params)"
+ ],
+ "execution_count": 3,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "xeU50hAZ9qCu"
+ },
+ "source": [
+ "# setup inputs\n",
+ "query_sequence = \"MQDGPGTLDVFVAAGWNTDNTIEITGGATYQLSPYIMVKAGYGWNNSSLNRFEFGGGLQYKVTPDLEPYAWAGATYNTDNTLVPAAGAGFRYKVSPEVKLVVEYGWNNSSLQFLQAGLSYRIQP\"\n",
+ "feature_dict = {\n",
+ " **pipeline.make_sequence_features(sequence=query_sequence,description=\"none\",num_res=len(query_sequence)),\n",
+ " **pipeline.make_msa_features(msas=[[query_sequence]],deletion_matrices=[[[0]*len(query_sequence)]]),\n",
+ "}\n",
+ "inputs = model_runner.process_features(feature_dict, random_seed=0)"
+ ],
+ "execution_count": 4,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kexOnJht9rx-"
+ },
+ "source": [
+ "# get outputs\n",
+ "outputs, prev_outputs = model_runner.predict(inputs)\n",
+ "plddts = np.asarray(jnp.concatenate([prev_outputs[\"prev_plddt\"], outputs['plddt'][None]],0))\n",
+ "positions = np.asarray(jnp.concatenate([prev_outputs[\"prev_pos\"], outputs['structure_module'][\"final_atom_positions\"][None]],0))"
+ ],
+ "execution_count": 5,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YJeexRmFvn43"
+ },
+ "source": [
+ "LET'S ANIMATE"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "7zh3M5h8qOSa"
+ },
+ "source": [
+ "import matplotlib\n",
+ "from matplotlib import animation\n",
+ "import matplotlib.pyplot as plt\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "def make_animation(positions, plddts=None, line_w=2.0):\n",
+ "\n",
+ " def ca_align_to_last(positions):\n",
+ " def align(P, Q):\n",
+ " p = P - P.mean(0,keepdims=True)\n",
+ " q = Q - Q.mean(0,keepdims=True)\n",
+ " return p @ cf.kabsch(p,q)\n",
+ " \n",
+ " pos = positions[-1,:,1,:] - positions[-1,:,1,:].mean(0,keepdims=True)\n",
+ " best_2D_view = pos @ cf.kabsch(pos,pos,return_v=True)\n",
+ "\n",
+ " new_positions = []\n",
+ " for i in range(len(positions)):\n",
+ " new_positions.append(align(positions[i,:,1,:],best_2D_view))\n",
+ " return np.asarray(new_positions)\n",
+ "\n",
+ " # align all to last recycle\n",
+ " pos = ca_align_to_last(positions)\n",
+ "\n",
+ " fig, (ax1, ax2, ax3) = plt.subplots(1,3)\n",
+ " fig.subplots_adjust(top = 0.90, bottom = 0.10, right = 1, left = 0, hspace = 0, wspace = 0)\n",
+ " fig.set_figwidth(13)\n",
+ " fig.set_figheight(5)\n",
+ " fig.set_dpi(100)\n",
+ "\n",
+ " xy_min = pos[...,:2].min() - 1\n",
+ " xy_max = pos[...,:2].max() + 1\n",
+ "\n",
+ " for ax in [ax1,ax3]:\n",
+ " ax.set_xlim(xy_min, xy_max)\n",
+ " ax.set_ylim(xy_min, xy_max)\n",
+ " ax.axis(False)\n",
+ "\n",
+ " ims=[]\n",
+ " for k,(xyz,plddt) in enumerate(zip(pos,plddts)):\n",
+ " ims.append([])\n",
+ " im2 = ax2.plot(plddt, animated=True, color=\"black\")\n",
+ " tt1 = cf.add_text(\"colored by N->C\", ax1)\n",
+ " tt2 = cf.add_text(f\"recycle={k}\", ax2)\n",
+ " tt3 = cf.add_text(f\"pLDDT={plddt.mean():.3f}\", ax3)\n",
+ " ax2.set_xlabel(\"positions\")\n",
+ " ax2.set_ylabel(\"pLDDT\")\n",
+ " ax2.set_ylim(0,100)\n",
+ " ims[-1] += [cf.plot_pseudo_3D(xyz, ax=ax1, line_w=line_w)]\n",
+ " ims[-1] += [im2[0],tt1,tt2,tt3]\n",
+ " ims[-1] += [cf.plot_pseudo_3D(xyz, c=plddt, cmin=50, cmax=90, ax=ax3, line_w=line_w)]\n",
+ " \n",
+ " ani = animation.ArtistAnimation(fig, ims, blit=True, interval=120)\n",
+ " plt.close()\n",
+ " return ani.to_html5_video()"
+ ],
+ "execution_count": 6,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 521
+ },
+ "id": "AbHs3lN_sPjS",
+ "outputId": "b2933ffb-1d93-4594-b308-bcafa9c24934"
+ },
+ "source": [
+ "HTML(make_animation(positions, plddts))"
+ ],
+ "execution_count": 7,
+ "outputs": [
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/html": [
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "SW7PGft_TTOL"
+ },
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "if not os.path.isdir(\"params\"):\n",
+ " print(\"downloading weights...\")\n",
+ " os.system(\"mkdir params\")\n",
+ " os.system(\"apt-get install aria2 -qq\")\n",
+ " os.system(\"aria2c -q -x 16 https://storage.googleapis.com/alphafold/alphafold_params_2022-12-06.tar\")\n",
+ " os.system(\"tar -xf alphafold_params_2022-12-06.tar -C params\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import numpy as np\n",
+ "import pickle\n",
+ "\n",
+ "\n",
+ "example = \"test_a5e17_all_rank_001_alphafold2_ptm_model_3_seed_000.pickle\"\n",
+ "with open(example,\"rb\") as handle:\n",
+ " data = pickle.load(handle)\n",
+ "\n",
+ "model_num = example.split(\"_\")[-3]\n",
+ "if \"multimer_v3\" in example:\n",
+ " model_type = \"_multimer_v3\"\n",
+ "elif \"ptm\" in example:\n",
+ " model_type = \"_ptm\"\n",
+ "else:\n",
+ " model_type = \"\"\n",
+ "print(model_type, model_num)\n",
+ "model_params = np.load(f\"params/params_model_{model_num}{model_type}.npz\")\n",
+ "w = model_params['alphafold/alphafold_iteration/evoformer/single_activations//weights']\n",
+ "b = model_params['alphafold/alphafold_iteration/evoformer/single_activations//bias']\n",
+ "single_rep_256 = data[\"representations\"][\"single\"]\n",
+ "single_rep_384 = data[\"representations\"][\"single\"] @ w + b\n",
+ "\n",
+ "print(single_rep_256.shape, single_rep_384.shape)"
+ ],
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "KXV8XWuuT0pN",
+ "outputId": "02c3003e-e72c-4e70-cb8c-7625def016d6"
+ },
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "ptm 3\n",
+ "(59, 256) (59, 384)\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {
+ "id": "HPEnv_C3td-D"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/folding.patch b/data/beta/folding.patch
new file mode 100644
index 0000000000000000000000000000000000000000..5e17ed6f145ed880fef1f84f72ca5fa84a0fef1a
--- /dev/null
+++ b/data/beta/folding.patch
@@ -0,0 +1,34 @@
+--- /content/alphafold_copy/alphafold/model/folding.py 2022-06-16 23:22:42.489230552 +0000
++++ /content/alphafold/alphafold/model/folding.py 2022-06-16 23:46:03.017505449 +0000
+@@ -440,21 +440,17 @@
+ name='pair_layer_norm')(
+ representations['pair'])
+
+- outputs = []
+- safe_keys = safe_key.split(c.num_layer)
+- for sub_key in safe_keys:
+- activations, output = fold_iteration(
+- activations,
+- initial_act=initial_act,
+- static_feat_2d=act_2d,
+- safe_key=sub_key,
+- sequence_mask=sequence_mask,
+- update_affine=True,
+- is_training=is_training,
+- aatype=batch['aatype'])
+- outputs.append(output)
++ def fold_iter(act, key):
++ return fold_iteration(act, initial_act=initial_act,
++ static_feat_2d=act_2d,
++ safe_key=prng.SafeKey(key),
++ sequence_mask=sequence_mask,
++ update_affine=True,
++ is_training=is_training,
++ aatype=batch['aatype'])
++ keys = jax.random.split(safe_key.get(), c.num_layer)
++ activations, output = hk.scan(fold_iter, activations, keys)
+
+- output = jax.tree_map(lambda *x: jnp.stack(x), *outputs)
+ # Include the activations in the output dict for use by the LDDT-Head.
+ output['act'] = activations['act']
+
diff --git a/data/beta/mapping.patch b/data/beta/mapping.patch
new file mode 100644
index 0000000000000000000000000000000000000000..6e4f57cfd53f9ca9be06ecc2305519f4db220205
--- /dev/null
+++ b/data/beta/mapping.patch
@@ -0,0 +1,63 @@
+--- /content/alphafold_old/alphafold/model/mapping.py 2022-09-06 22:48:51.735105962 +0000
++++ /content/alphafold/alphafold/model/mapping.py 2022-09-06 22:55:15.646553551 +0000
+@@ -46,11 +46,11 @@
+
+
+ def _expand_axes(axes, values, name='sharded_apply'):
+- values_tree_def = jax.tree_flatten(values)[1]
++ values_tree_def = jax.tree_util.tree_flatten(values)[1]
+ flat_axes = jax.api_util.flatten_axes(name, values_tree_def, axes)
+ # Replace None's with PROXY
+ flat_axes = [PROXY if x is None else x for x in flat_axes]
+- return jax.tree_unflatten(values_tree_def, flat_axes)
++ return jax.tree_util.tree_unflatten(values_tree_def, flat_axes)
+
+
+ def sharded_map(
+@@ -120,8 +120,8 @@
+ # Expand in axes and Determine Loop range
+ in_axes_ = _expand_axes(in_axes, args)
+
+- in_sizes = jax.tree_multimap(_maybe_get_size, args, in_axes_)
+- flat_sizes = jax.tree_flatten(in_sizes)[0]
++ in_sizes = jax.tree_map(_maybe_get_size, args, in_axes_)
++ flat_sizes = jax.tree_util.tree_flatten(in_sizes)[0]
+ in_size = max(flat_sizes)
+ assert all(i in {in_size, -1} for i in flat_sizes)
+
+@@ -132,7 +132,7 @@
+ last_shard_size = shard_size if last_shard_size == 0 else last_shard_size
+
+ def apply_fun_to_slice(slice_start, slice_size):
+- input_slice = jax.tree_multimap(
++ input_slice = jax.tree_map(
+ lambda array, axis: _maybe_slice(array, slice_start, slice_size, axis
+ ), args, in_axes_)
+ return fun(*input_slice)
+@@ -153,7 +153,7 @@
+ shard_shape[axis] * num_extra_shards +
+ remainder_shape[axis],) + shard_shape[axis + 1:]
+
+- out_shapes = jax.tree_multimap(make_output_shape, out_axes_, shard_shapes,
++ out_shapes = jax.tree_map(make_output_shape, out_axes_, shard_shapes,
+ out_shapes)
+
+ # Calls dynamic Update slice with different argument order
+@@ -165,7 +165,7 @@
+ slice_out = apply_fun_to_slice(slice_start, slice_size)
+ update_slice = partial(
+ dynamic_update_slice_in_dim, i=slice_start)
+- return jax.tree_multimap(update_slice, outputs, slice_out, out_axes_)
++ return jax.tree_map(update_slice, outputs, slice_out, out_axes_)
+
+ def scan_iteration(outputs, i):
+ new_outputs = compute_shard(outputs, i, shard_size)
+@@ -176,7 +176,7 @@
+ def allocate_buffer(dtype, shape):
+ return jnp.zeros(shape, dtype=dtype)
+
+- outputs = jax.tree_multimap(allocate_buffer, out_dtypes, out_shapes)
++ outputs = jax.tree_map(allocate_buffer, out_dtypes, out_shapes)
+
+ if slice_starts.shape[0] > 0:
+ outputs, _ = hk.scan(scan_iteration, outputs, slice_starts)
diff --git a/data/beta/model.patch b/data/beta/model.patch
new file mode 100644
index 0000000000000000000000000000000000000000..747a5c5108e86bbe7229f479b334619b417b9869
--- /dev/null
+++ b/data/beta/model.patch
@@ -0,0 +1,70 @@
+--- /content/alphafold_copy/alphafold/model/model.py 2022-06-21 02:56:28.903256585 +0000
++++ /content/alphafold/alphafold/model/model.py 2022-06-21 03:08:21.392362049 +0000
+@@ -50,7 +50,8 @@
+
+ def __init__(self,
+ config: ml_collections.ConfigDict,
+- params: Optional[Mapping[str, Mapping[str, np.ndarray]]] = None):
++ params: Optional[Mapping[str, Mapping[str, np.ndarray]]] = None,
++ is_training = False):
+ self.config = config
+ self.params = params
+
+@@ -58,7 +59,7 @@
+ model = modules.AlphaFold(self.config.model)
+ return model(
+ batch,
+- is_training=False,
++ is_training=is_training,
+ compute_loss=False,
+ ensemble_representations=True)
+
+@@ -117,7 +118,7 @@
+ logging.info('Output shape was %s', shape)
+ return shape
+
+- def predict(self, feat: features.FeatureDict) -> Mapping[str, Any]:
++ def predict(self, feat: features.FeatureDict, random_seed=0) -> Mapping[str, Any]:
+ """Makes a prediction by inferencing the model on the provided features.
+
+ Args:
+@@ -128,14 +129,28 @@
+ A dictionary of model outputs.
+ """
+ self.init_params(feat)
+- logging.info('Running predict with shape(feat) = %s',
+- tree.map_structure(lambda x: x.shape, feat))
+- result = self.apply(self.params, jax.random.PRNGKey(0), feat)
+- # This block is to ensure benchmark timings are accurate. Some blocking is
+- # already happening when computing get_confidence_metrics, and this ensures
+- # all outputs are blocked on.
+- jax.tree_map(lambda x: x.block_until_ready(), result)
+- result.update(get_confidence_metrics(result))
+- logging.info('Output shape was %s',
+- tree.map_structure(lambda x: x.shape, result))
+- return result
++ logging.info('Running predict with shape(feat) = %s', tree.map_structure(lambda x: x.shape, feat))
++
++ aatype = feat["aatype"]
++ num_iters = self.config.model.num_recycle + 1
++ num_ensemble = self.config.data.eval.num_ensemble
++ L = aatype.shape[1]
++ result = {"prev":{'prev_msa_first_row': np.zeros([L,256]),
++ 'prev_pair': np.zeros([L,L,128]),
++ 'prev_pos': np.zeros([L,37,3])}}
++
++ r = 0
++ key = jax.random.PRNGKey(random_seed)
++ while r < num_iters:
++ s = r * num_ensemble
++ e = (r+1) * num_ensemble
++ sub_feat = jax.tree_map(lambda x:x[s:e], feat)
++ sub_feat["prev"] = result["prev"]
++ result, _ = self.apply(self.params, key, sub_feat)
++ del sub_feat
++ confidences = get_confidence_metrics(result)
++ result.update(confidences)
++ r += 1
++
++ logging.info('Output shape was %s', tree.map_structure(lambda x: x.shape, result))
++ return result, (r-1,0)
diff --git a/data/beta/modules.patch b/data/beta/modules.patch
new file mode 100644
index 0000000000000000000000000000000000000000..fbdb976ad536a3479cc0dd43ad9b17a3a4f6bdc4
--- /dev/null
+++ b/data/beta/modules.patch
@@ -0,0 +1,80 @@
+--- /content/alphafold_copy/alphafold/model/modules.py 2022-06-16 23:22:42.489230552 +0000
++++ /content/alphafold/alphafold/model/modules.py 2022-06-16 23:33:50.394462860 +0000
+@@ -322,7 +322,7 @@
+ recycle_idx,
+ compute_loss=compute_loss):
+ if self.config.resample_msa_in_recycling:
+- num_ensemble = batch_size // (self.config.num_recycle + 1)
++ num_ensemble = batch_size
+ def slice_recycle_idx(x):
+ start = recycle_idx * num_ensemble
+ size = num_ensemble
+@@ -341,53 +341,16 @@
+ compute_loss=compute_loss,
+ ensemble_representations=ensemble_representations)
+
+- if self.config.num_recycle:
+- emb_config = self.config.embeddings_and_evoformer
+- prev = {
+- 'prev_pos': jnp.zeros(
+- [num_residues, residue_constants.atom_type_num, 3]),
+- 'prev_msa_first_row': jnp.zeros(
+- [num_residues, emb_config.msa_channel]),
+- 'prev_pair': jnp.zeros(
+- [num_residues, num_residues, emb_config.pair_channel]),
+- }
+-
+- if 'num_iter_recycling' in batch:
+- # Training time: num_iter_recycling is in batch.
+- # The value for each ensemble batch is the same, so arbitrarily taking
+- # 0-th.
+- num_iter = batch['num_iter_recycling'][0]
+-
+- # Add insurance that we will not run more
+- # recyclings than the model is configured to run.
+- num_iter = jnp.minimum(num_iter, self.config.num_recycle)
+- else:
+- # Eval mode or tests: use the maximum number of iterations.
+- num_iter = self.config.num_recycle
+-
+- body = lambda x: (x[0] + 1, # pylint: disable=g-long-lambda
+- get_prev(do_call(x[1], recycle_idx=x[0],
+- compute_loss=False)))
+- if hk.running_init():
+- # When initializing the Haiku module, run one iteration of the
+- # while_loop to initialize the Haiku modules used in `body`.
+- _, prev = body((0, prev))
+- else:
+- _, prev = hk.while_loop(
+- lambda x: x[0] < num_iter,
+- body,
+- (0, prev))
+- else:
+- prev = {}
+- num_iter = 0
++ emb_config = self.config.embeddings_and_evoformer
++ ret = do_call(prev=batch.pop("prev"), recycle_idx=0)
++ ret["prev"] = get_prev(ret)
+
+- ret = do_call(prev=prev, recycle_idx=num_iter)
+ if compute_loss:
+ ret = ret[0], [ret[1]]
+
+ if not return_representations:
+ del (ret[0] if compute_loss else ret)['representations'] # pytype: disable=unsupported-operands
+- return ret
++ return ret, (None, None)
+
+
+ class TemplatePairStack(hk.Module):
+@@ -1730,9 +1693,7 @@
+ True,
+ name='prev_msa_first_row_norm')(
+ batch['prev_msa_first_row'])
+- msa_activations = jax.ops.index_add(msa_activations, 0,
+- prev_msa_first_row)
+-
++ msa_activations = msa_activations.at[0].add(prev_msa_first_row)
+ if 'prev_pair' in batch:
+ pair_activations += hk.LayerNorm([-1],
+ True,
diff --git a/data/beta/omegafold.ipynb b/data/beta/omegafold.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..dab7f25a433b887fe3f61babffbeac63945cd345
--- /dev/null
+++ b/data/beta/omegafold.ipynb
@@ -0,0 +1,239 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "omegafold.ipynb",
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU",
+ "gpuClass": "standard"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#**OmegaFold**\n",
+ "for more details see: [Github](https://github.com/HeliXonProtein/OmegaFold), [Preprint](https://www.biorxiv.org/content/10.1101/2022.07.21.500999v1)\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "- use \"/\" to specify chainbreaks, (eg. sequence=\"AAA/AAA\")\n",
+ "- for homo-oligomeric predictions, set copies > 1\n"
+ ],
+ "metadata": {
+ "id": "qEgffIPOyEgk"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "oVkGfduwiAkw"
+ },
+ "outputs": [],
+ "source": [
+ "#@markdown ##Install\n",
+ "import os,sys,re\n",
+ "from IPython.utils import io\n",
+ "if \"SETUP_DONE\" not in dir():\n",
+ " import torch\n",
+ " device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ " with io.capture_output() as captured:\n",
+ " if not os.path.isdir(\"OmegaFold\"):\n",
+ " %shell git clone --branch beta --quiet https://github.com/sokrypton/OmegaFold.git\n",
+ " # %shell cd OmegaFold; pip -q install -r requirements.txt\n",
+ " %shell pip -q install py3Dmol biopython==1.81\n",
+ " %shell apt-get install aria2 -qq > /dev/null\n",
+ " %shell aria2c -q -x 16 https://helixon.s3.amazonaws.com/release1.pt\n",
+ " %shell mkdir -p ~/.cache/omegafold_ckpt\n",
+ " %shell mv release1.pt ~/.cache/omegafold_ckpt/model.pt\n",
+ " SETUP_DONE = True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@markdown ##Run **OmegaFold**\n",
+ "from string import ascii_uppercase, ascii_lowercase\n",
+ "import hashlib\n",
+ "\n",
+ "def get_hash(x): return hashlib.sha1(x.encode()).hexdigest()\n",
+ "alphabet_list = list(ascii_uppercase+ascii_lowercase)\n",
+ "\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "jobname = re.sub(r'\\W+', '', jobname)[:50]\n",
+ "\n",
+ "sequence = \"PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK\" #@param {type:\"string\"}\n",
+ "sequence = re.sub(\"[^A-Z:]\", \"\", sequence.replace(\"/\",\":\").upper())\n",
+ "sequence = re.sub(\":+\",\":\",sequence)\n",
+ "sequence = re.sub(\"^[:]+\",\"\",sequence)\n",
+ "sequence = re.sub(\"[:]+$\",\"\",sequence)\n",
+ "\n",
+ "copies = 1 #@param {type:\"integer\"}\n",
+ "sequence = \":\".join([sequence] * copies)\n",
+ "#@markdown **Advanced Options**\n",
+ "num_cycle = 4 #@param [\"1\", \"2\", \"4\", \"8\", \"16\", \"32\"] {type:\"raw\"}\n",
+ "offset_rope = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "ID = jobname+\"_\"+get_hash(sequence)[:5]\n",
+ "seqs = sequence.split(\":\")\n",
+ "lengths = [len(s) for s in seqs]\n",
+ "\n",
+ "def get_subbatch_size(L):\n",
+ " if L < 500: return 500\n",
+ " if L < 1000: return 200\n",
+ " return 150\n",
+ "subbatch_size = get_subbatch_size(sum(lengths))\n",
+ "\n",
+ "u_seqs = list(set(seqs))\n",
+ "\n",
+ "if len(seqs) == 1: mode = \"mono\"\n",
+ "elif len(u_seqs) == 1: mode = \"homo\"\n",
+ "else: mode = \"hetero\"\n",
+ "\n",
+ "with open(f\"{ID}.fasta\",\"w\") as out:\n",
+ " out.write(f\">{ID}\\n{sequence}\\n\")\n",
+ "\n",
+ "%shell python OmegaFold/main.py --offset_rope={offset_rope} --device={device} --subbatch_size={subbatch_size} --num_cycle={num_cycle} {ID}.fasta .\n",
+ "\n",
+ "def renum_pdb_str(pdb_str, Ls=None, renum=True, offset=1):\n",
+ " if Ls is not None:\n",
+ " L_init = 0\n",
+ " new_chain = {}\n",
+ " for L,c in zip(Ls, alphabet_list):\n",
+ " new_chain.update({i:c for i in range(L_init,L_init+L)})\n",
+ " L_init += L \n",
+ "\n",
+ " n,num,pdb_out = 0,offset,[]\n",
+ " resnum_ = None\n",
+ " chain_ = None\n",
+ " new_chain_ = new_chain[0]\n",
+ " for line in pdb_str.split(\"\\n\"):\n",
+ " if line[:4] == \"ATOM\":\n",
+ " chain = line[21:22]\n",
+ " resnum = int(line[22:22+5])\n",
+ " if resnum_ is None: resnum_ = resnum\n",
+ " if chain_ is None: chain_ = chain\n",
+ " if resnum != resnum_ or chain != chain_:\n",
+ " num += (resnum - resnum_) \n",
+ " n += 1\n",
+ " resnum_,chain_ = resnum,chain\n",
+ " if Ls is not None:\n",
+ " if new_chain[n] != new_chain_:\n",
+ " num = offset\n",
+ " new_chain_ = new_chain[n]\n",
+ " N = num if renum else resnum\n",
+ " if Ls is None: pdb_out.append(\"%s%4i%s\" % (line[:22],N,line[26:]))\n",
+ " else: pdb_out.append(\"%s%s%4i%s\" % (line[:21],new_chain[n],N,line[26:])) \n",
+ " return \"\\n\".join(pdb_out)\n",
+ "\n",
+ "pdb_str = renum_pdb_str(open(f\"{ID}.pdb\",'r').read(), Ls=lengths)\n",
+ "with open(f\"{ID}.pdb\",\"w\") as out:\n",
+ " out.write(pdb_str)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "CFCwEAa2oZEN"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@markdown ##Display\n",
+ "import py3Dmol\n",
+ "\n",
+ "\n",
+ "pymol_color_list = [\"#33ff33\",\"#00ffff\",\"#ff33cc\",\"#ffff00\",\"#ff9999\",\"#e5e5e5\",\"#7f7fff\",\"#ff7f00\",\n",
+ " \"#7fff7f\",\"#199999\",\"#ff007f\",\"#ffdd5e\",\"#8c3f99\",\"#b2b2b2\",\"#007fff\",\"#c4b200\",\n",
+ " \"#8cb266\",\"#00bfbf\",\"#b27f7f\",\"#fcd1a5\",\"#ff7f7f\",\"#ffbfdd\",\"#7fffff\",\"#ffff7f\",\n",
+ " \"#00ff7f\",\"#337fcc\",\"#d8337f\",\"#bfff3f\",\"#ff7fff\",\"#d8d8ff\",\"#3fffbf\",\"#b78c4c\",\n",
+ " \"#339933\",\"#66b2b2\",\"#ba8c84\",\"#84bf00\",\"#b24c66\",\"#7f7f7f\",\"#3f3fa5\",\"#a5512b\"]\n",
+ "\n",
+ "def show_pdb(pdb_str, show_sidechains=False, show_mainchains=False,\n",
+ " color=\"pLDDT\", chains=None, vmin=50, vmax=90,\n",
+ " size=(800,480), hbondCutoff=4.0,\n",
+ " Ls=None,\n",
+ " animate=False):\n",
+ " \n",
+ " if chains is None:\n",
+ " chains = 1 if Ls is None else len(Ls)\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js', width=size[0], height=size[1])\n",
+ " if animate:\n",
+ " view.addModelsAsFrames(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " else:\n",
+ " view.addModel(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " if color == \"pLDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':vmin,'max':vmax}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " HP = [\"ALA\",\"GLY\",\"VAL\",\"ILE\",\"LEU\",\"PHE\",\"MET\",\"PRO\",\"TRP\",\"CYS\",\"TYR\"]\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}}) \n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.zoomTo()\n",
+ " if animate: view.animate()\n",
+ " return view\n",
+ "\n",
+ "color = \"confidence\" #@param [\"confidence\", \"rainbow\", \"chain\"]\n",
+ "if color == \"confidence\": color = \"pLDDT\"\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "show_pdb(pdb_str, color=color, show_sidechains=show_sidechains, show_mainchains=show_mainchains,\n",
+ " Ls=lengths).show()"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "dHl9aS-HHFNQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Download prediction\n",
+ "from google.colab import files\n",
+ "files.download(f'{ID}.pdb')"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "12rxVAHSrmYQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/data/beta/omegafold_hacks.ipynb b/data/beta/omegafold_hacks.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1d7ffec6964ddc1deeddfb89ba78577b8193dd17
--- /dev/null
+++ b/data/beta/omegafold_hacks.ipynb
@@ -0,0 +1,287 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "omegafold_hacks.ipynb",
+ "provenance": [],
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU",
+ "gpuClass": "standard"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#**OmegaFold_hacks**\n",
+ "**WARNING** This is an experimental notebook that implements various hacks (unintended uses) of OmegaFold. It has not been optimized or benchmarked. Use at your own risk!\n",
+ "\n",
+ "For detail about the original model see: [Github](https://github.com/HeliXonProtein/OmegaFold), [Preprint](https://www.biorxiv.org/content/10.1101/2022.07.21.500999v1)\n",
+ "\n",
+ "\n",
+ "#### **Tips and Instructions**\n",
+ "- click the little ▶ play icon to the left of each cell below.\n",
+ "\n",
+ "#### **Experimental Options**\n",
+ "- use \"/\" to specify chainbreaks, (eg. sequence=\"AAA/AAA\")\n",
+ "- if confidence of prediction is low, try `use_real_msa` (currently only supported for monomeric and homo-oligomeric predictions)\n"
+ ],
+ "metadata": {
+ "id": "qEgffIPOyEgk"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "oVkGfduwiAkw"
+ },
+ "outputs": [],
+ "source": [
+ "#@markdown ##Install\n",
+ "import os,sys,re\n",
+ "from IPython.utils import io\n",
+ "if \"SETUP_DONE\" not in dir():\n",
+ " import torch\n",
+ " device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+ " with io.capture_output() as captured:\n",
+ " if not os.path.isdir(\"OmegaFold\"):\n",
+ " %shell git clone --quiet https://github.com/sokrypton/OmegaFold.git\n",
+ " %shell cd OmegaFold; pip -q install -r requirements.txt\n",
+ " %shell pip -q install py3Dmol\n",
+ " %shell apt-get install aria2 -qq > /dev/null\n",
+ " %shell aria2c -q -x 16 https://helixon.s3.amazonaws.com/release1.pt\n",
+ " %shell mkdir -p ~/.cache/omegafold_ckpt\n",
+ " %shell mv release1.pt ~/.cache/omegafold_ckpt/model.pt\n",
+ " %shell wget -qnc https://github.com/soedinglab/hh-suite/releases/download/v3.3.0/hhsuite-3.3.0-SSE2-Linux.tar.gz\n",
+ " %shell tar xfz hhsuite-3.3.0-SSE2-Linux.tar.gz\n",
+ " %shell wget -qnc https://raw.githubusercontent.com/sokrypton/ColabFold/main/colabfold/colabfold.py\n",
+ " os.environ['PATH'] += \":/content/bin:/content/scripts\"\n",
+ " SETUP_DONE = True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@markdown ##Prep inputs\n",
+ "from string import ascii_uppercase, ascii_lowercase\n",
+ "import colabfold as cf\n",
+ "alphabet_list = list(ascii_uppercase+ascii_lowercase)\n",
+ "\n",
+ "sequence = \"PIAQIHILEGRSDEQKETLIREVSEAISRSLDAPLTSVRVIITEMAKGHFGIGGELASK\" #@param {type:\"string\"}\n",
+ "jobname = \"test\" #@param {type:\"string\"}\n",
+ "\n",
+ "# filter inputs\n",
+ "sequence = re.sub(\"[^A-Z:/]\", \"\", sequence.upper())\n",
+ "sequence = re.sub(\":+\",\":\",sequence)\n",
+ "sequence = re.sub(\"/+\",\"/\",sequence)\n",
+ "sequence = re.sub(\"^[:/]+\",\"\",sequence)\n",
+ "sequence = re.sub(\"[:/]+$\",\"\",sequence)\n",
+ "jobname = re.sub(r'\\W+', '', jobname)[:50]\n",
+ "\n",
+ "num_msa = 16\n",
+ "use_real_msa = False #@param {type:\"boolean\"}\n",
+ "\n",
+ "sequence = re.sub(\"[^A-Z\\/\\:]\", \"\", sequence.upper()).replace(\"/\",\":\")\n",
+ "ID = jobname+\"_\"+cf.get_hash(sequence)[:5]\n",
+ "seqs = sequence.split(\":\")\n",
+ "lengths = [len(s) for s in seqs]\n",
+ "u_seqs = list(set(seqs))\n",
+ "\n",
+ "if len(seqs) == 1: mode = \"mono\"\n",
+ "elif len(u_seqs) == 1: mode = \"homo\"\n",
+ "else: mode = \"hetero\"\n",
+ "\n",
+ "if use_real_msa and mode == \"hetero\":\n",
+ " print(\"ERROR: the msa mode is currently not supported for hetero-multimers\")\n",
+ " use_real_msa = False\n",
+ "\n",
+ "if use_real_msa:\n",
+ " ID_ = cf.get_hash(seqs[0])[:5]\n",
+ " a3m_lines = cf.run_mmseqs2(seqs[0], ID_, filter=True)[0]\n",
+ " with open(f\"{ID}.a3m\",\"w\") as a3m:\n",
+ " a3m.write(a3m_lines)\n",
+ " \n",
+ " %shell hhfilter -v 0 -qid 30 -cov 75 -diff {num_msa} -i {ID}.a3m -o {ID}.fasta\n",
+ " \n",
+ " a3m_lines = open(f\"{ID}.fasta\",\"r\").readlines()\n",
+ " with open(f\"{ID}.fasta\",\"w\") as a3m:\n",
+ " n = 0\n",
+ " for a3m_line in a3m_lines:\n",
+ " if a3m_line.startswith(\">\"):\n",
+ " if n == 0:\n",
+ " a3m.write(f\">{ID}\\n\")\n",
+ " else:\n",
+ " a3m.write(a3m_line)\n",
+ " else:\n",
+ " a3m_line = \":\".join([a3m_line.rstrip()] * len(lengths))\n",
+ " a3m.write(f\"{a3m_line}\\n\")\n",
+ " n += 1\n",
+ " if n == num_msa: break\n",
+ " # add pseudo_msa\n",
+ " while n < num_msa:\n",
+ " a3m.write(f\">tmp\\n{sequence}\\n\")\n",
+ " n += 1\n",
+ "else:\n",
+ " with open(f\"{ID}.fasta\",\"w\") as out:\n",
+ " out.write(f\">{ID}\\n{sequence}\\n\")"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "CFCwEAa2oZEN"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "%%time \n",
+ "#@markdown ## Run OmegaFold\n",
+ "num_cycle = 4 #@param [\"1\", \"2\", \"4\", \"8\", \"16\", \"32\"] {type:\"raw\"}\n",
+ "\n",
+ "if use_real_msa:\n",
+ " %shell python ./OmegaFold/main.py --device={device} --num_cycle={num_cycle} --real_msa=1 {ID}.fasta .\n",
+ "else:\n",
+ " %shell python ./OmegaFold/main.py --device={device} --num_cycle={num_cycle} --num_pseudo_msa={num_msa-1} {ID}.fasta .\n",
+ "\n",
+ "def renum_pdb_str(pdb_str, Ls=None, renum=True, offset=1):\n",
+ " if Ls is not None:\n",
+ " L_init = 0\n",
+ " new_chain = {}\n",
+ " for L,c in zip(Ls, alphabet_list):\n",
+ " new_chain.update({i:c for i in range(L_init,L_init+L)})\n",
+ " L_init += L \n",
+ "\n",
+ " n,num,pdb_out = 0,offset,[]\n",
+ " resnum_ = None\n",
+ " chain_ = None\n",
+ " new_chain_ = new_chain[0]\n",
+ " for line in pdb_str.split(\"\\n\"):\n",
+ " if line[:4] == \"ATOM\":\n",
+ " chain = line[21:22]\n",
+ " resnum = int(line[22:22+5])\n",
+ " if resnum_ is None: resnum_ = resnum\n",
+ " if chain_ is None: chain_ = chain\n",
+ " if resnum != resnum_ or chain != chain_:\n",
+ " num += (resnum - resnum_) \n",
+ " n += 1\n",
+ " resnum_,chain_ = resnum,chain\n",
+ " if Ls is not None:\n",
+ " if new_chain[n] != new_chain_:\n",
+ " num = offset\n",
+ " new_chain_ = new_chain[n]\n",
+ " N = num if renum else resnum\n",
+ " if Ls is None: pdb_out.append(\"%s%4i%s\" % (line[:22],N,line[26:]))\n",
+ " else: pdb_out.append(\"%s%s%4i%s\" % (line[:21],new_chain[n],N,line[26:])) \n",
+ " return \"\\n\".join(pdb_out)\n",
+ "\n",
+ "pdb_str = renum_pdb_str(open(f\"{ID}.pdb\",'r').read(), Ls=lengths)\n",
+ "with open(f\"{ID}.pdb\",\"w\") as out:\n",
+ " out.write(pdb_str)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "_tUY92JL28DS"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@markdown ##Display\n",
+ "import py3Dmol\n",
+ "\n",
+ "\n",
+ "pymol_color_list = [\"#33ff33\",\"#00ffff\",\"#ff33cc\",\"#ffff00\",\"#ff9999\",\"#e5e5e5\",\"#7f7fff\",\"#ff7f00\",\n",
+ " \"#7fff7f\",\"#199999\",\"#ff007f\",\"#ffdd5e\",\"#8c3f99\",\"#b2b2b2\",\"#007fff\",\"#c4b200\",\n",
+ " \"#8cb266\",\"#00bfbf\",\"#b27f7f\",\"#fcd1a5\",\"#ff7f7f\",\"#ffbfdd\",\"#7fffff\",\"#ffff7f\",\n",
+ " \"#00ff7f\",\"#337fcc\",\"#d8337f\",\"#bfff3f\",\"#ff7fff\",\"#d8d8ff\",\"#3fffbf\",\"#b78c4c\",\n",
+ " \"#339933\",\"#66b2b2\",\"#ba8c84\",\"#84bf00\",\"#b24c66\",\"#7f7f7f\",\"#3f3fa5\",\"#a5512b\"]\n",
+ "\n",
+ "def show_pdb(pdb_str, show_sidechains=False, show_mainchains=False,\n",
+ " color=\"pLDDT\", chains=None, vmin=50, vmax=90,\n",
+ " size=(800,480), hbondCutoff=4.0,\n",
+ " Ls=None,\n",
+ " animate=False):\n",
+ " \n",
+ " if chains is None:\n",
+ " chains = 1 if Ls is None else len(Ls)\n",
+ " view = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js', width=size[0], height=size[1])\n",
+ " if animate:\n",
+ " view.addModelsAsFrames(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " else:\n",
+ " view.addModel(pdb_str,'pdb',{'hbondCutoff':hbondCutoff})\n",
+ " if color == \"pLDDT\":\n",
+ " view.setStyle({'cartoon': {'colorscheme': {'prop':'b','gradient': 'roygb','min':vmin,'max':vmax}}})\n",
+ " elif color == \"rainbow\":\n",
+ " view.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " elif color == \"chain\":\n",
+ " for n,chain,color in zip(range(chains),alphabet_list,pymol_color_list):\n",
+ " view.setStyle({'chain':chain},{'cartoon': {'color':color}})\n",
+ " if show_sidechains:\n",
+ " BB = ['C','O','N']\n",
+ " HP = [\"ALA\",\"GLY\",\"VAL\",\"ILE\",\"LEU\",\"PHE\",\"MET\",\"PRO\",\"TRP\",\"CYS\",\"TYR\"]\n",
+ " view.addStyle({'and':[{'resn':[\"GLY\",\"PRO\"],'invert':True},{'atom':BB,'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"GLY\"},{'atom':'CA'}]},\n",
+ " {'sphere':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.addStyle({'and':[{'resn':\"PRO\"},{'atom':['C','O'],'invert':True}]},\n",
+ " {'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}}) \n",
+ " if show_mainchains:\n",
+ " BB = ['C','O','N','CA']\n",
+ " view.addStyle({'atom':BB},{'stick':{'colorscheme':f\"WhiteCarbon\",'radius':0.3}})\n",
+ " view.zoomTo()\n",
+ " if animate: view.animate()\n",
+ " return view\n",
+ "\n",
+ "color = \"confidence\" #@param [\"confidence\", \"rainbow\", \"chain\"]\n",
+ "if color == \"confidence\": color = \"pLDDT\"\n",
+ "show_sidechains = False #@param {type:\"boolean\"}\n",
+ "show_mainchains = False #@param {type:\"boolean\"}\n",
+ "show_pdb(pdb_str, color=color, show_sidechains=show_sidechains, show_mainchains=show_mainchains,\n",
+ " Ls=lengths).show()"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "e6rpvs0Nqix5"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title Download prediction\n",
+ "from google.colab import files\n",
+ "files.download(f'{ID}.pdb')"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "12rxVAHSrmYQ"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/beta/pairmsa.py b/data/beta/pairmsa.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6e27d7fea89fd82a91745cd7e5015cd39e7c581
--- /dev/null
+++ b/data/beta/pairmsa.py
@@ -0,0 +1,237 @@
+import numpy as np
+from string import ascii_uppercase, ascii_lowercase
+import urllib.parse
+import urllib.request
+import time
+
+def parse_a3m(a3m_lines=None, a3m_file=None, filter_qid=0.15, filter_cov=0.5, N=100000):
+
+ def seqid(a, b):
+ return sum(c1 == c2 for c1, c2 in zip(a, b))
+
+ def nongaps(a):
+ return sum(c != "-" for c in a)
+
+ def chk(seq, ref_seq):
+ rL = len(ref_seq)
+ L = nongaps(seq)
+ return not (L > filter_cov*rL and seqid(seq, ref_seq) > filter_qid*L)
+
+ rm_lower = str.maketrans('','',ascii_lowercase)
+
+ # prep inputs
+ if a3m_lines is None: a3m_lines = open(a3m_file,"r")
+ else: a3m_lines = a3m_lines.splitlines()
+
+ # parse inputs
+ n,nams,seqs,mtx = 0,[],[],[]
+ def do_filter():
+ seq = seqs[-1].translate(rm_lower)
+ if "_UPI" in nams[-1] or chk(seq,ref_seq):
+ nams.pop()
+ seqs.pop()
+ else:
+ # deletion matrix
+ deletion_vec = []
+ deletion_count = 0
+ for j in seqs[-1]:
+ if j.islower():
+ deletion_count += 1
+ else:
+ deletion_vec.append(deletion_count)
+ deletion_count = 0
+ mtx.append(deletion_vec)
+ seqs[-1] = seq
+
+ for line in a3m_lines:
+ line = line.rstrip()
+ if line.startswith(">"):
+ if n == 1:
+ ref_seq = seqs[0].translate(rm_lower)
+ if n >= 1:
+ # filter previous entry
+ do_filter()
+ # start new sequence entry
+ nam = line.split()[0][1:]
+ if "_" not in nam: nam = f"X_{nam}"
+ nams.append(nam)
+ seqs.append("")
+ n += 1
+ else:
+ seqs[-1] += line
+
+ # filter last entry
+ do_filter()
+
+ if len(seqs) > N+1:
+ print(f"found too many sequences ({len(seqs)}), taking the top{N} (sorted by qid)")
+ sid = np.argsort([seqid(seq,ref_seq) for seq in seqs])[::-1][:N+1]
+ seqs = [seqs[i] for i in sid]
+ mtx = [mtx[i] for i in sid]
+ nams = [nams[i] for i in sid]
+ return seqs[1:],mtx[1:],nams[1:]
+
+def get_uni_jackhmmer(msa, mtx, lab, filter_qid=0.15, filter_cov=0.5):
+ '''filter entries to uniprot'''
+ lab_,msa_,mtx_ = [],[],[]
+ ref_seq = np.array(list(msa[0]))
+ rL = len(ref_seq)
+ for l,s,x in zip(lab[1:],msa[1:],mtx[1:]):
+ if l.startswith("UniRef"):
+ l = l.split("/")[0]
+ if "_UPI" not in l:
+ tar_seq = np.array(list(s))
+ L = (tar_seq != "-").sum()
+ qid = (ref_seq == tar_seq).sum()
+ if L > filter_cov * rL and qid > filter_qid * L:
+ lab_.append(l)
+ msa_.append(s)
+ mtx_.append(x)
+ return msa_, mtx_, lab_
+
+def uni_num(ids):
+ ########################################
+ pa = {a:0 for a in ascii_uppercase}
+ for a in ["O","P","Q"]: pa[a] = 1
+ ma = [[{} for k in range(6)],[{} for k in range(6)]]
+ for n,t in enumerate(range(10)):
+ for i in [0,1]:
+ for j in [0,4]: ma[i][j][str(t)] = n
+ for n,t in enumerate(list(ascii_uppercase)+list(range(10))):
+ for i in [0,1]:
+ for j in [1,2]: ma[i][j][str(t)] = n
+ ma[1][3][str(t)] = n
+ for n,t in enumerate(ascii_uppercase):
+ ma[0][3][str(t)] = n
+ for i in [0,1]: ma[i][5][str(t)] = n
+ ########################################
+ nums = []
+ for uni in ids:
+ p = pa[uni[0]]
+ tot, num = 1,0
+ if len(uni) == 10:
+ for n,u in enumerate(reversed(uni[-4:])):
+ num += ma[p][n][u] * tot
+ tot *= len(ma[p][n].keys())
+ for n,u in enumerate(reversed(uni[:6])):
+ num += ma[p][n][u] * tot
+ tot *= len(ma[p][n].keys())
+ nums.append(num)
+ return nums
+
+def map_retrieve(ids, call_uniprot=False):
+
+ if call_uniprot:
+ mode = "NF100" if "UniRef100" in ids[0] else "NF90"
+ url = 'https://www.uniprot.org/uploadlists/'
+ out = []
+ for i in range(0,len(ids),5000):
+ params = {
+ 'from': mode,
+ 'to': 'ACC',
+ 'format': 'tab',
+ 'query': " ".join(ids[i:i+5000])
+ }
+ data = urllib.parse.urlencode(params)
+ data = data.encode('utf-8')
+ req = urllib.request.Request(url, data)
+ with urllib.request.urlopen(req) as f:
+ response = f.read()
+ out += [line.split() for line in response.decode('utf-8').splitlines()]
+ time.sleep(5)
+
+ # combine mapping
+ mapping = {}
+ for i,j in out:
+ if i != "From":
+ if i not in mapping:
+ mapping[i] = [j]
+ else:
+ mapping[i].append(j)
+ else:
+ mapping = {}
+
+ for i in ids:
+ if i not in mapping:
+ mapping[i] = [i.split("_")[1]]
+
+ return mapping
+
+def hash_it(_seq, _lab, _mtx, call_uniprot=False):
+ if _seq is None or _lab is None:
+ _seq, _lab = parse_a3m(a3m_lines)
+
+ _lab_to_seq = {L:S for L,S in zip(_lab,_seq)}
+ _lab_to_mtx = {L:M for L,M in zip(_lab,_mtx)}
+
+ # call uniprot
+ _lab_to_uni = map_retrieve(_lab, call_uniprot=call_uniprot)
+
+ _uni_to_lab = {}
+ for L,U in _lab_to_uni.items():
+ for u in U: _uni_to_lab[u] = L
+
+ _uni,__lab = [],[]
+ for U,L in _uni_to_lab.items():
+ _uni.append(U)
+ __lab.append(L)
+
+ _hash = uni_num(_uni)
+ _uni_to_hash = {u:h for u,h in zip(_uni,_hash)}
+ _hash_to_lab = {h:l for h,l in zip(_hash,__lab)}
+
+ _lab_to_hash = {}
+ for L,U in _lab_to_uni.items():
+ _lab_to_hash[L] = []
+ for u in U: _lab_to_hash[L].append(_uni_to_hash[u])
+
+ return {"_lab_to_seq":_lab_to_seq,
+ "_lab_to_mtx":_lab_to_mtx,
+ "_lab_to_hash":_lab_to_hash,
+ "_hash_to_lab":_hash_to_lab}
+
+import tqdm.notebook
+TQDM_BAR_FORMAT = '{l_bar}{bar}| {n_fmt}/{total_fmt} [elapsed: {elapsed} remaining: {remaining}]'
+
+# keeping old function for compatability
+def stitch(_hash_a,_hash_b, stitch_min=1, stitch_max=20, filter_id=None):
+ o = _stitch(_hash_a, _hash_b, stitch_min, stitch_max)
+ return (*o["seq"],*o["mtx"])
+
+def _stitch(_hash_a,_hash_b, stitch_min=1, stitch_max=20):
+ _seq, _mtx, _lab, _delta_gene = [[],[]],[[],[]],[[],[]],[]
+ TOTAL = len(_hash_a["_lab_to_hash"])
+ with tqdm.notebook.tqdm(total=TOTAL, bar_format=TQDM_BAR_FORMAT) as pbar:
+ pbar.set_description("STITCHING")
+ H_A = np.asarray(list(_hash_a["_hash_to_lab"].keys()))
+ H_B = np.asarray(list(_hash_b["_hash_to_lab"].keys()))
+
+ def hit(h,H):
+ h = np.asarray(h)
+ match = np.abs(h[:,None]-H[None,:]).min(0)
+ match_min = match.min()
+ if match_min >= stitch_min and match_min <= stitch_max:
+ return True,H[match.argmin()],match_min
+ else:
+ return False,None,None
+
+ for n,(l_a,h_a) in enumerate(_hash_a["_lab_to_hash"].items()):
+ chk_b, h_b, dg = hit(h_a,H_B)
+ if chk_b:
+ l_b = _hash_b["_hash_to_lab"][h_b]
+ h_b = _hash_b["_lab_to_hash"][l_b]
+ chk_c, h_c, _ = hit(h_b,H_A)
+ if chk_c and _hash_a["_hash_to_lab"][h_c] == l_a:
+ _seq[0].append(_hash_a["_lab_to_seq"][l_a])
+ _mtx[0].append(_hash_a["_lab_to_mtx"][l_a])
+ _lab[0].append(l_a)
+ _seq[1].append(_hash_b["_lab_to_seq"][l_b])
+ _mtx[1].append(_hash_b["_lab_to_mtx"][l_b])
+ _lab[1].append(l_b)
+ _delta_gene.append(dg)
+ pbar.update()
+
+ return {"seq":_seq,
+ "mtx":_mtx,
+ "lab":_lab,
+ "delta_gene":_delta_gene}
diff --git a/data/beta/protein.patch b/data/beta/protein.patch
new file mode 100644
index 0000000000000000000000000000000000000000..02543c45bac7dabca2a1873139113e02eb840fb4
--- /dev/null
+++ b/data/beta/protein.patch
@@ -0,0 +1,126 @@
+--- /content/alphafold_ori/common/protein.py 2021-08-10 10:03:26.580274340 +0000
++++ /content/alphafold/alphafold/common/protein.py 2021-08-10 10:04:47.660884323 +0000
+@@ -19,6 +19,9 @@
+ from alphafold.common import residue_constants
+ from Bio.PDB import PDBParser
+ import numpy as np
++from string import ascii_uppercase,ascii_lowercase
++
++CHAIN_IDs = ascii_uppercase+ascii_lowercase
+
+ FeatureDict = Mapping[str, np.ndarray]
+ ModelOutput = Mapping[str, Any] # Is a nested dict.
+@@ -75,14 +78,15 @@
+
+ if chain_id is not None:
+ chain = model[chain_id]
++ chains = [chain]
+ else:
+ chains = list(model.get_chains())
+- if len(chains) != 1:
+- raise ValueError(
+- 'Only single chain PDBs are supported when chain_id not specified. '
+- f'Found {len(chains)} chains.')
+- else:
+- chain = chains[0]
++ # if len(chains) != 1:
++ # raise ValueError(
++ # 'Only single chain PDBs are supported when chain_id not specified. '
++ # f'Found {len(chains)} chains.')
++ # else:
++ # chain = chains[0]
+
+ atom_positions = []
+ aatype = []
+@@ -90,31 +94,35 @@
+ residue_index = []
+ b_factors = []
+
+- for res in chain:
+- if res.id[2] != ' ':
+- raise ValueError(
+- f'PDB contains an insertion code at chain {chain.id} and residue '
+- f'index {res.id[1]}. These are not supported.')
+- res_shortname = residue_constants.restype_3to1.get(res.resname, 'X')
+- restype_idx = residue_constants.restype_order.get(
+- res_shortname, residue_constants.restype_num)
+- pos = np.zeros((residue_constants.atom_type_num, 3))
+- mask = np.zeros((residue_constants.atom_type_num,))
+- res_b_factors = np.zeros((residue_constants.atom_type_num,))
+- for atom in res:
+- if atom.name not in residue_constants.atom_types:
++ PARAM_CHAIN_BREAK = 100
++ residue_index_prev = 0
++ for k,chain in enumerate(chains):
++ for res in chain:
++ if res.id[2] != ' ':
++ raise ValueError(
++ f'PDB contains an insertion code at chain {chain.id} and residue '
++ f'index {res.id[1]}. These are not supported.')
++ res_shortname = residue_constants.restype_3to1.get(res.resname, 'X')
++ restype_idx = residue_constants.restype_order.get(
++ res_shortname, residue_constants.restype_num)
++ pos = np.zeros((residue_constants.atom_type_num, 3))
++ mask = np.zeros((residue_constants.atom_type_num,))
++ res_b_factors = np.zeros((residue_constants.atom_type_num,))
++ for atom in res:
++ if atom.name not in residue_constants.atom_types:
++ continue
++ pos[residue_constants.atom_order[atom.name]] = atom.coord
++ mask[residue_constants.atom_order[atom.name]] = 1.
++ res_b_factors[residue_constants.atom_order[atom.name]] = atom.bfactor
++ if np.sum(mask) < 0.5:
++ # If no known atom positions are reported for the residue then skip it.
+ continue
+- pos[residue_constants.atom_order[atom.name]] = atom.coord
+- mask[residue_constants.atom_order[atom.name]] = 1.
+- res_b_factors[residue_constants.atom_order[atom.name]] = atom.bfactor
+- if np.sum(mask) < 0.5:
+- # If no known atom positions are reported for the residue then skip it.
+- continue
+- aatype.append(restype_idx)
+- atom_positions.append(pos)
+- atom_mask.append(mask)
+- residue_index.append(res.id[1])
+- b_factors.append(res_b_factors)
++ aatype.append(restype_idx)
++ atom_positions.append(pos)
++ atom_mask.append(mask)
++ residue_index.append(res.id[1] + residue_index_prev + PARAM_CHAIN_BREAK*k)
++ b_factors.append(res_b_factors)
++ residue_index_prev = residue_index[-1]
+
+ return Protein(
+ atom_positions=np.array(atom_positions),
+@@ -150,10 +158,21 @@
+
+ pdb_lines.append('MODEL 1')
+ atom_index = 1
+- chain_id = 'A'
++ chain_index = -1
++ residue_index_prev = residue_index[0]-100
+ # Add all atom sites.
+ for i in range(aatype.shape[0]):
++ if residue_index[i] - residue_index_prev > 1: # chain break
++ chain_index += 1
++ res_num = 1
++ if chain_index > 0:
++ pdb_lines.append("TER")
++ elif residue_index[i] != residue_index_prev:
++ res_num += 1
++ residue_index_prev = residue_index[i]
++ chain_id = CHAIN_IDs[chain_index]
+ res_name_3 = res_1to3(aatype[i])
++ #
+ for atom_name, pos, mask, b_factor in zip(
+ atom_types, atom_positions[i], atom_mask[i], b_factors[i]):
+ if mask < 0.5:
+@@ -169,7 +188,7 @@
+ # PDB is a columnar format, every space matters here!
+ atom_line = (f'{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}'
+ f'{res_name_3:>3} {chain_id:>1}'
+- f'{residue_index[i]:>4}{insertion_code:>1} '
++ f'{res_num:>4}{insertion_code:>1} '
+ f'{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}'
+ f'{occupancy:>6.2f}{b_factor:>6.2f} '
+ f'{element:>2}{charge:>2}')
diff --git a/data/beta/recycle_0.patch b/data/beta/recycle_0.patch
new file mode 100644
index 0000000000000000000000000000000000000000..1ed9fc1d0ef7a21050eed1cb81e63383a9e9b4dc
--- /dev/null
+++ b/data/beta/recycle_0.patch
@@ -0,0 +1,37 @@
+--- /usr/local/lib/python3.7/dist-packages/alphafold/model/modules.py 2022-03-23 04:02:56.871333044 +0000
++++ alphafold/alphafold/model/modules.py 2022-03-23 04:04:16.081234108 +0000
+@@ -341,17 +341,16 @@
+ compute_loss=compute_loss,
+ ensemble_representations=ensemble_representations)
+
++ emb_config = self.config.embeddings_and_evoformer
++ prev = {
++ 'prev_pos': jnp.zeros(
++ [num_residues, residue_constants.atom_type_num, 3]),
++ 'prev_msa_first_row': jnp.zeros(
++ [num_residues, emb_config.msa_channel]),
++ 'prev_pair': jnp.zeros(
++ [num_residues, num_residues, emb_config.pair_channel]),
++ }
+ if self.config.num_recycle:
+- emb_config = self.config.embeddings_and_evoformer
+- prev = {
+- 'prev_pos': jnp.zeros(
+- [num_residues, residue_constants.atom_type_num, 3]),
+- 'prev_msa_first_row': jnp.zeros(
+- [num_residues, emb_config.msa_channel]),
+- 'prev_pair': jnp.zeros(
+- [num_residues, num_residues, emb_config.pair_channel]),
+- }
+-
+ if 'num_iter_recycling' in batch:
+ # Training time: num_iter_recycling is in batch.
+ # The value for each ensemble batch is the same, so arbitrarily taking
+@@ -378,7 +377,6 @@
+ body,
+ (0, prev))
+ else:
+- prev = {}
+ num_iter = 0
+
+ ret = do_call(prev=prev, recycle_idx=num_iter)
diff --git a/data/beta/relax_amber.ipynb b/data/beta/relax_amber.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d4a20cf68e819d9cf3c52b57b23601531dc011a7
--- /dev/null
+++ b/data/beta/relax_amber.ipynb
@@ -0,0 +1,207 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "provenance": [],
+ "runtime_attributes": {
+ "runtime_version": "2025.07"
+ }
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "\n",
+ "\n",
+ "\n",
+ "# Relax your structure using OpenMM/Amber\n",
+ "\n",
+ "Easy to use protein structure relaxation using [AlphaFold2](https://www.nature.com/articles/s41586-021-03819-2) and [OpenMM](https://github.com/openmm/openmm).\n",
+ "\n",
+ "This notebooks is part of ColabFold. See [GitHub](https://github.com/sokrypton/ColabFold) for other notebooks.\n",
+ "\n",
+ "[Mirdita M, Schütze K, Moriwaki Y, Heo L, Ovchinnikov S, Steinegger M. ColabFold: Making protein folding accessible to all.\n",
+ "*Nature Methods*, 2022](https://www.nature.com/articles/s41592-022-01488-1)\n"
+ ],
+ "metadata": {
+ "id": "rvfNfOLaE4bW"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "%%time\n",
+ "#@title Setup AlphaFold2 and OpenMM\n",
+ "import sys, os\n",
+ "from sys import version_info\n",
+ "PYTHON_VERSION = f\"{version_info.major}.{version_info.minor}\"\n",
+ "\n",
+ "if not os.path.isfile(\"ALPHAFOLD_READY\"):\n",
+ " print(\"installing AlphaFold...\")\n",
+ " os.system(\"pip install alphafold-colabfold\")\n",
+ " os.system(\"ln -s /usr/local/lib/python3.*/dist-packages/alphafold alphafold\")\n",
+ " os.system(\"touch ALPHAFOLD_READY\")\n",
+ "\n",
+ "if not os.path.isfile(\"CONDA_READY\"):\n",
+ " print(\"installing conda...\")\n",
+ " os.system(\"wget -qnc https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh\")\n",
+ " os.system(\"bash Miniforge3-Linux-x86_64.sh -bfp /usr/local\")\n",
+ " os.system(\"mamba config --set auto_update_conda false\")\n",
+ " os.system(\"touch CONDA_READY\")\n",
+ "\n",
+ "if not os.path.isfile(\"AMBER_READY\"):\n",
+ " print(\"installing amber...\")\n",
+ " os.system(f\"mamba install -y -q -c conda-forge openmm=8.2.0 python='{PYTHON_VERSION}' pdbfixer 2>&1 1>/dev/null\")\n",
+ " os.system(\"touch AMBER_READY\")\n",
+ "\n",
+ "PATH = f\"/usr/local/lib/python{PYTHON_VERSION}/site-packages/\"\n",
+ "if PATH not in sys.path:\n",
+ " sys.path.insert(0, PATH)\n",
+ "\n",
+ "import warnings\n",
+ "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
+ "\n",
+ "from alphafold.relax import relax\n",
+ "from alphafold.relax import utils\n",
+ "from alphafold.common import protein, residue_constants\n",
+ "\n",
+ "MODRES = {'MSE':'MET','MLY':'LYS','FME':'MET','HYP':'PRO',\n",
+ " 'TPO':'THR','CSO':'CYS','SEP':'SER','M3L':'LYS',\n",
+ " 'HSK':'HIS','SAC':'SER','PCA':'GLU','DAL':'ALA',\n",
+ " 'CME':'CYS','CSD':'CYS','OCS':'CYS','DPR':'PRO',\n",
+ " 'B3K':'LYS','ALY':'LYS','YCM':'CYS','MLZ':'LYS',\n",
+ " '4BF':'TYR','KCX':'LYS','B3E':'GLU','B3D':'ASP',\n",
+ " 'HZP':'PRO','CSX':'CYS','BAL':'ALA','HIC':'HIS',\n",
+ " 'DBZ':'ALA','DCY':'CYS','DVA':'VAL','NLE':'LEU',\n",
+ " 'SMC':'CYS','AGM':'ARG','B3A':'ALA','DAS':'ASP',\n",
+ " 'DLY':'LYS','DSN':'SER','DTH':'THR','GL3':'GLY',\n",
+ " 'HY3':'PRO','LLP':'LYS','MGN':'GLN','MHS':'HIS',\n",
+ " 'TRQ':'TRP','B3Y':'TYR','PHI':'PHE','PTR':'TYR',\n",
+ " 'TYS':'TYR','IAS':'ASP','GPL':'LYS','KYN':'TRP',\n",
+ " 'CSD':'CYS','SEC':'CYS'}\n",
+ "\n",
+ "def pdb_to_string(pdb_file, chains=None, models=[1]):\n",
+ " '''read pdb file and return as string'''\n",
+ "\n",
+ " if chains is not None:\n",
+ " if \",\" in chains: chains = chains.split(\",\")\n",
+ " if not isinstance(chains,list): chains = [chains]\n",
+ " if models is not None:\n",
+ " if not isinstance(models,list): models = [models]\n",
+ "\n",
+ " modres = {**MODRES}\n",
+ " lines = []\n",
+ " seen = []\n",
+ " model = 1\n",
+ " for line in open(pdb_file,\"rb\"):\n",
+ " line = line.decode(\"utf-8\",\"ignore\").rstrip()\n",
+ " if line[:5] == \"MODEL\":\n",
+ " model = int(line[5:])\n",
+ " if models is None or model in models:\n",
+ " if line[:6] == \"MODRES\":\n",
+ " k = line[12:15]\n",
+ " v = line[24:27]\n",
+ " if k not in modres and v in residue_constants.restype_3to1:\n",
+ " modres[k] = v\n",
+ " if line[:6] == \"HETATM\":\n",
+ " k = line[17:20]\n",
+ " if k in modres:\n",
+ " line = \"ATOM \"+line[6:17]+modres[k]+line[20:]\n",
+ " if line[:4] == \"ATOM\":\n",
+ " chain = line[21:22]\n",
+ " if chains is None or chain in chains:\n",
+ " atom = line[12:12+4].strip()\n",
+ " resi = line[17:17+3]\n",
+ " resn = line[22:22+5].strip()\n",
+ " if resn[-1].isalpha(): # alternative atom\n",
+ " resn = resn[:-1]\n",
+ " line = line[:26]+\" \"+line[27:]\n",
+ " key = f\"{model}_{chain}_{resn}_{resi}_{atom}\"\n",
+ " if key not in seen: # skip alternative placements\n",
+ " lines.append(line)\n",
+ " seen.append(key)\n",
+ " if line[:5] == \"MODEL\" or line[:3] == \"TER\" or line[:6] == \"ENDMDL\":\n",
+ " lines.append(line)\n",
+ " return \"\\n\".join(lines)\n",
+ "\n",
+ "def relax_me(pdb_in, pdb_out, max_iterations, tolerance, stiffness, use_gpu):\n",
+ " pdb_str = pdb_to_string(pdb_in)\n",
+ " protein_obj = protein.from_pdb_string(pdb_str)\n",
+ " amber_relaxer = relax.AmberRelaxation(\n",
+ " max_iterations=max_iterations,\n",
+ " tolerance=tolerance,\n",
+ " stiffness=stiffness,\n",
+ " exclude_residues=[],\n",
+ " max_outer_iterations=3,\n",
+ " use_gpu=use_gpu\n",
+ " )\n",
+ " relaxed_pdb_lines, _, _ = amber_relaxer.process(prot=protein_obj)\n",
+ " with open(pdb_out, 'w') as f:\n",
+ " f.write(relaxed_pdb_lines)"
+ ],
+ "metadata": {
+ "cellView": "form",
+ "id": "1KKjet38pMys"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "#@title #Relax\n",
+ "#@markdown - Click the little ▶ play icon to the left to get an upload prompt.\n",
+ "#@markdown - After relax is done, `relaxed.pdb` will automatically download.\n",
+ "#@markdown - If download was blocked, click the little folder 📁 icon on the left, right-click `relaxed.pdb` and select Download!\n",
+ "#@markdown ----\n",
+ "#@markdown ## Parameters\n",
+ "max_iterations = 2000 #@param {type:\"slider\", min:0, max:5000, step:250}\n",
+ "#@markdown - Low values might never converge and crash and high values might also run for a long time. `0` = infinity is the AF2 default, however it might run for a long time.\n",
+ "tolerance = 2.39 # @param {type:\"number\"}\n",
+ "#@markdown - kcal/mol, the energy tolerance of L-BFGS.\n",
+ "stiffness = 10.0 # @param {type:\"number\"}\n",
+ "#@markdown - kcal/mol A^2, spring constant of heavy atom restraining potential.\n",
+ "#@markdown - **Note:** Descriptions and default values are taken AF2.\n",
+ "use_gpu = False # @param {type:\"boolean\"}\n",
+ "#@markdown - set \"Runtime->Change runtime type\" to a GPU in Google Colab if you activate this.\n",
+ "\n",
+ "from google.colab import files\n",
+ "pdb_dict = files.upload()\n",
+ "relax_me(\n",
+ " pdb_in=list(pdb_dict.keys())[0],\n",
+ " pdb_out=\"relaxed.pdb\",\n",
+ " max_iterations=max_iterations,\n",
+ " tolerance=tolerance,\n",
+ " stiffness=stiffness,\n",
+ " use_gpu=use_gpu\n",
+ ")\n",
+ "files.download(f'relaxed.pdb')"
+ ],
+ "metadata": {
+ "id": "rEekqQXQ-Pec",
+ "cellView": "form"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/data/colabfold/__init__.py b/data/colabfold/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/data/colabfold/alphafold/__init__.py b/data/colabfold/alphafold/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/data/colabfold/alphafold/extra_ptm.py b/data/colabfold/alphafold/extra_ptm.py
new file mode 100644
index 0000000000000000000000000000000000000000..6059c78000f994a9d305f5fdd215935cb0a0c5a6
--- /dev/null
+++ b/data/colabfold/alphafold/extra_ptm.py
@@ -0,0 +1,435 @@
+import numpy as np
+import string
+from copy import deepcopy
+import jax.numpy as jnp
+import jax
+import scipy
+import pandas as pd
+
+from alphafold.common import confidence
+
+""" Functions to calculate interface metrics on actual interfaces"""
+def get_dgram_bins(result):
+ """From colabdesign, calculate bin boundaries of distogram"""
+ dgram = result["distogram"]["logits"]
+ if dgram.shape[-1] == 64:
+ dgram_bins = jnp.append(0,jnp.linspace(2.3125,21.6875,63))
+ if dgram.shape[-1] == 39:
+ dgram_bins = jnp.linspace(3.25,50.75,39) + 1.25
+ return dgram_bins
+
+
+def get_contact_map(result, dist=8.0):
+ """From colabdesign, get contact map from distogram"""
+ dist_logits = result["distogram"]["logits"]
+ dist_bins = get_dgram_bins(result)
+ return (jax.nn.softmax(dist_logits) * (dist_bins < dist)).sum(-1)
+
+
+def get_chain_indices(asym_id, use_jnp=True):
+ """Returns a list of tuples indicating the start and end indices for each chain."""
+
+ chain_starts_ends = []
+ unique_chains = np.unique(asym_id) # chains are numbered 0, 1, 2, ...
+
+ for chain in unique_chains:
+ positions = np.where(asym_id == chain)[0]
+ chain_starts_ends.append((positions[0], positions[-1]))
+
+ return chain_starts_ends
+
+
+def predicted_tm_score_modified(logits, breaks, residue_weights=None,
+ asym_id=None, pair_residue_weights=None, use_jnp=False, ):
+ """Computes predicted TM alignment or predicted interface TM alignment score.
+
+ Args:
+ logits: [num_res, num_res, num_bins] the logits output from
+ PredictedAlignedErrorHead.
+ breaks: [num_bins] the error bins.
+ residue_weights: [num_res] the per residue weights to use for the
+ expectation.
+ asym_id: [num_res] the asymmetric unit ID - the chain ID. Only needed for
+ ipTM calculation.
+ pair_residue_weights: [num_res, num_res] unnormalized weights for actifptm calculation
+
+ Returns:
+ ptm_score: The predicted TM alignment or the predicted iTM score.
+ """
+ if use_jnp:
+ _np, _softmax = jnp, jax.nn.softmax
+ else:
+ _np, _softmax = np, scipy.special.softmax
+
+ # residue_weights has to be in [0, 1], but can be floating-point, i.e. the
+ # exp. resolved head's probability.
+ if residue_weights is None:
+ residue_weights = _np.ones(logits.shape[0])
+ bin_centers = confidence._calculate_bin_centers(breaks, use_jnp=use_jnp)
+ num_res = residue_weights.shape[0]
+
+ # Clip num_res to avoid negative/undefined d0.
+ clipped_num_res = _np.maximum(num_res, 19)
+
+ # Compute d_0(num_res) as defined by TM-score, eqn. (5) in Yang & Skolnick
+ # "Scoring function for automated assessment of protein structure template
+ # quality", 2004: http://zhanglab.ccmb.med.umich.edu/papers/2004_3.pdf
+ d0 = 1.24 * (clipped_num_res - 15) ** (1. / 3) - 1.8
+
+ # Convert logits to probs.
+ probs = _softmax(logits, axis=-1)
+
+ # TM-Score term for every bin.
+ tm_per_bin = 1. / (1 + _np.square(bin_centers) / _np.square(d0))
+
+ # E_distances tm(distance).
+ predicted_tm_term = (probs * tm_per_bin).sum(-1)
+
+ if asym_id is None:
+ pair_mask = _np.full((num_res, num_res), True)
+ else:
+ pair_mask = asym_id[:, None] != asym_id[None, :]
+
+ predicted_tm_term *= pair_mask
+
+ # If pair_residue_weights is provided (e.g. for if_ptm with contact probabilities),
+ # it should not be overwritten
+ if pair_residue_weights is None:
+ pair_residue_weights = pair_mask * (residue_weights[None, :] * residue_weights[:, None])
+ normed_residue_mask = pair_residue_weights / (1e-8 + pair_residue_weights.sum(-1, keepdims=True))
+
+ per_alignment = (predicted_tm_term * normed_residue_mask).sum(-1)
+ residuewise_iptm = per_alignment * residue_weights
+
+ return residuewise_iptm
+
+
+def get_ptm_modified(inputs, outputs, interface=False):
+ """ This function is the same as in the original AF2, just calls a modified TM-score calculation function."""
+
+ pae = {"residue_weights": inputs["seq_mask"], **outputs["predicted_aligned_error"]}
+
+ if interface:
+ if "asym_id" not in pae:
+ pae["asym_id"] = inputs["asym_id"]
+ else:
+ if "asym_id" in pae:
+ pae.pop("asym_id")
+
+ return predicted_tm_score_modified(**pae, use_jnp=True)
+
+
+def get_actifptm_probs(result, asym_id, cmap, start_i, end_i, start_j, end_j):
+ """
+ This function calculates the interface PTM score for a given interface, taking into account the contact probabilities, not binary contacts.
+
+ Args:
+ af: AlphaFold object
+ cmap: Contact map
+ start_i, end_i: Start and end indices of the first chain
+ start_j, end_j: Start and end indices of the second chain
+
+ Returns:
+ actifptm: Interface pTM score
+ """
+
+ total_length = len(asym_id)
+ outputs = deepcopy(result)
+
+ # Create a new matrix, which contains only the contacts between the two chains
+ cmap_copy = np.zeros((total_length, total_length))
+ cmap_copy[start_i:end_i + 1, start_j:end_j + 1] = cmap[start_i:end_i + 1, start_j:end_j + 1]
+ cmap_copy[start_j:end_j + 1, start_i:end_i + 1] = cmap[start_j:end_j + 1, start_i:end_i + 1]
+
+ # this is for the full-length actifptm
+ if end_i == end_j == total_length - 1 and start_i == start_j == 0:
+ pair_mask = asym_id[:, None] != asym_id[None, :]
+ cmap_copy *= pair_mask
+
+ # Update seq_mask for these positions to True within inputs
+ seq_mask = np.full(total_length, 0, dtype=float)
+ seq_mask[np.concatenate((np.arange(start_i, end_i + 1),
+ np.arange(start_j, end_j + 1)))] = 1
+
+ # Call get_ptm with updated inputs and outputs
+ pae = {"residue_weights": seq_mask,
+ **outputs["predicted_aligned_error"],
+ "asym_id": asym_id}
+ residuewise_actifptm = predicted_tm_score_modified(**pae, use_jnp=True, pair_residue_weights=cmap_copy)
+
+ return residuewise_actifptm
+
+
+def get_actifptm_contacts(result, asym_id, cmap, start_i, end_i, start_j, end_j):
+ """
+ This function calculates the interface PTM score for a given interface, taking into account binary contacts.
+ In case of no confident contacts, the interface PTM score is set to 0.
+
+ Args:
+ af: AlphaFold object
+ cmap: Contact map
+ start_i, end_i: Start and end indices of the first chain
+ start_j, end_j: Start and end indices of the second chain
+
+ Returns:
+ actifptm: Interface pTM score
+ """
+
+ # Prepare a dictionary to collect the inputs for calculation
+ inputs_actifptm = {}
+ contacts = np.where(cmap[start_i:end_i + 1, start_j:end_j + 1] >= 0.6)
+ total_length = len(asym_id)
+ outputs = deepcopy(result)
+
+ if contacts[0].size > 0: # If there are contacts
+ # Convert local chain positions back to global positions using JAX
+ global_i_positions = contacts[0] + start_i
+ global_j_positions = contacts[1] + start_j
+ global_positions = list(set(np.concatenate((global_i_positions, global_j_positions))))
+ global_positions = np.array(global_positions, dtype=int)
+ global_positions.sort()
+
+ # Initialize new input dictionary
+ inputs_actifptm['asym_id'] = asym_id
+ inputs_actifptm['seq_mask'] = np.full(total_length, 0, dtype=float)
+ inputs_actifptm['seq_mask'][global_positions] = 1
+
+ # Call get_ptm with updated inputs and outputs
+ residuewise_actifptm = get_ptm_modified(inputs_actifptm, outputs, interface=True)
+ else:
+ residuewise_actifptm = np.array([0.0])
+ inputs_actifptm['seq_mask'] = np.full(total_length, 0, dtype=float)
+
+ return residuewise_actifptm, inputs_actifptm['seq_mask']
+
+
+def get_pairwise_iptm(result, asym_id, start_i, end_i, start_j, end_j):
+ """This will calculate ipTM as usual, just between given chains"""
+
+ input_pairwise_iptm = {}
+
+ # Prepare inputs
+ outputs = deepcopy(result)
+ input_pairwise_iptm['seq_mask'] = np.full(len(asym_id), 0, dtype=float)
+ input_pairwise_iptm['asym_id'] = asym_id
+ input_pairwise_iptm['seq_mask'][np.concatenate((np.arange(start_i, end_i + 1),
+ np.arange(start_j, end_j + 1)))] = 1
+
+ return get_ptm_modified(input_pairwise_iptm, outputs, interface=True)
+
+
+def get_per_chain_ptm(result, cmap, start, end):
+ """
+ Calculates the chain PTM score for a specified interface region, using contact probabilities.
+
+ Args:
+ af: AlphaFold object
+ cmap: Contact map
+ start: Start index of the interface region
+ end: End index of the interface region
+
+ Returns:
+ cpTM: Chain pTM score
+ """
+ # Extract only the relevant subset of the contact map
+ cmap_subset = cmap[start:end + 1, start:end + 1]
+
+ # Extract only the relevant subset of the logits map
+ pae_copy = deepcopy(result)["predicted_aligned_error"]
+ pae_copy['logits'] = pae_copy['logits'][start:end + 1, start:end + 1, :]
+
+ # Prepare inputs for the modified predicted_tm_score function
+ pae_copy['residue_weights'] = np.ones(end - start + 1, dtype=float)
+ pae_copy.pop('asym_id', None)
+
+ # Calculate and return chain PTM score
+ cptm = round(float(predicted_tm_score_modified(**pae_copy, use_jnp=True).max()), 3)
+
+ return cptm
+
+
+def get_chain_and_interface_metrics(result, asym_id, use_probs_extra=False, use_jnp=True):
+ """
+ This function iterates over all pairs of chains and calculates the interface and interchain PTM score for each pair.
+
+ Args:
+ result: The result from AlphaFold.
+ asym_id: Array indicating chain boundaries.
+ use_probs_extra: If True, calculate interface pTM score based on contact probabilities. Default is False.
+ use_jnp: If True, use JAX numpy. Default is True.
+ Returns:
+ a dictionary with the pairwise interface pTM-s, and the chain-wise pTM.
+ returns None for each, if there was an error finding the logits for the pae matrix
+ """
+ # this is to deal with the ptm models (af2 monomer)
+ if len(asym_id.shape) > 1:
+ asym_id = asym_id[0]
+
+ full_length = len(asym_id)
+ # Prepare dictionaries to collect results
+ output = {'pairwise_actifptm': {}, 'pairwise_iptm': {}, 'per_chain_ptm': {}}
+ #residuewise_output = {'residuewise_actifptm': {}, 'residuewise_iptm': {}}
+ chain_starts_ends = get_chain_indices(asym_id, use_jnp=use_jnp)
+ pair_residue_weights_no_probs = np.zeros((full_length, full_length), dtype=float)
+
+ # Generate chain labels (A, B, C, ...)
+ chain_labels = list(string.ascii_uppercase)
+
+ # Define interface with 8A between Cb-s
+ cmap = get_contact_map(result, 8)
+
+ # This is for compatibility between colabdesign and colabfold
+ results = {}
+ if isinstance(result['predicted_aligned_error'], (np.ndarray, list)):
+ if 'pae_matrix_with_logits' in result.keys():
+ results['predicted_aligned_error'] = deepcopy(result['pae_matrix_with_logits'])
+ else:
+ print('There was an error retrieving the predicted aligned error matrix.')
+ return {"pairwise_actifptm": None, "pairwise_iptm": None, "per_chain_ptm": None, 'actifptm': None}
+ else:
+ results['predicted_aligned_error'] = deepcopy(result['predicted_aligned_error'])
+
+ for i, (start_i, end_i) in enumerate(chain_starts_ends):
+ chain_label_i = chain_labels[i % len(chain_labels)] # Wrap around if more than 26 chains
+ for j, (start_j, end_j) in enumerate(chain_starts_ends):
+ chain_label_j = chain_labels[j % len(chain_labels)] # Wrap around if more than 26 chains
+ if i < j: # Avoid self-comparison and duplicate comparisons
+ key = f"{chain_label_i}-{chain_label_j}"
+ if not use_probs_extra:
+ residuewise_actifptm, seq_mask = get_actifptm_contacts(results, asym_id, cmap, start_i, end_i, start_j, end_j)
+ pair_residue_weights_no_probs += seq_mask[None, :] * seq_mask[:, None]
+ output['pairwise_actifptm'][key] = round(float(residuewise_actifptm.max()), 3)
+ #residuewise_output['residuewise_actifptm'][key] = residuewise_actifptm
+ else:
+ residuewise_actifptm = get_actifptm_probs(results, asym_id, cmap, start_i, end_i, start_j, end_j)
+ output['pairwise_actifptm'][key] = round(float(residuewise_actifptm.max()), 3)
+ #residuewise_output['residuewise_actifptm'][key] = residuewise_actifptm
+
+
+ # Also add regular i_ptm (interchain), pairwise
+ residuewise_iptm = get_pairwise_iptm(results, asym_id, start_i, end_i, start_j, end_j)
+ output['pairwise_iptm'][key] = round(float(residuewise_iptm.max()), 3)
+ #residuewise_output['residuewise_iptm'][key] = output['pairwise_iptm'][key]
+
+ # Also calculate pTM score for single chain
+ output['per_chain_ptm'][chain_label_i] = get_per_chain_ptm(results, cmap, start_i, end_i)
+
+ if not use_probs_extra:
+ # we need to recreate the full matrix from the previously calculated contacts
+ pair_mask = asym_id[:, None] != asym_id[None, :]
+ pair_residue_weights_no_probs *= pair_mask
+ pae = {"residue_weights": np.full(full_length, 1, dtype=float),
+ **results["predicted_aligned_error"],
+ "asym_id": asym_id}
+ output['actifptm'] = round(float(predicted_tm_score_modified(**pae, pair_residue_weights=pair_residue_weights_no_probs).max()), 3)
+ else:
+ output['actifptm'] = round(float(get_actifptm_probs(results, asym_id, cmap, 0, full_length - 1, 0, full_length - 1).max()), 3)
+
+ return output
+
+
+def plot_matrix(actifptm_dict, iptm_dict, cptm_dict, prefix='rank', ax_in=None, fig_path=None):
+ """This function plots the metrics in a matrix. The diagonal will be chain-wise pTM-s,
+ the lower triangle displays actifptm and the upper triangle the ipTM (calculated in the original way)."""
+ from matplotlib import pyplot as plt
+ if not ax_in: # In case, we are not plotting multiple models next to each other
+ fig, ax = plt.subplots(1, 1, figsize=(5, 5), squeeze=False)
+
+ # get chain ids
+ letters = sorted(set([key.split('-')[0] for key in actifptm_dict.keys()] + [key.split('-')[1] for key in actifptm_dict.keys()]))
+
+ # initialize dataframe
+ data = pd.DataFrame(np.zeros((len(letters), len(letters))), index=letters, columns=letters)
+
+ # populate dataframe with ifptm and iptm values
+ for key, value in actifptm_dict.items():
+ i, j = key.split('-')
+ data.loc[j, i] = value
+ data.loc[i, j] = iptm_dict[f'{i}-{j}']
+
+ # add cptm values to the dataframe
+ for chain, value in cptm_dict.items():
+ if chain in data.index:
+ data.loc[chain, chain] = value
+
+ # create masks for lower, upper triangles, and diagonal
+ mask_upper = np.triu(np.ones(data.shape), k=1)
+ mask_lower = np.tril(np.ones(data.shape), k=-1)
+ mask_diagonal = np.eye(data.shape[0])
+
+ dyn_size_ch = max(- 1.5 * len(letters) + 18, 3) # resize the font with differently sized figures
+ # Plot lower triangle (actifpTM)
+ ax_in.imshow(np.ma.masked_where(mask_upper + mask_diagonal, data), cmap='Blues', vmax=1, vmin=0)
+
+ # Plot upper triangle (ipTM)
+ ax_in.imshow(np.ma.masked_where(mask_lower + mask_diagonal, data), cmap='Reds', vmax=1, vmin=0)
+
+ # Plot diagonal (cpTM)
+ diagonal_data = np.diag(np.diag(data))
+ im = ax_in.imshow(np.ma.masked_where(~mask_diagonal.astype(bool), diagonal_data), cmap='Greys', vmax=1, vmin=0)
+
+ # Add colorbar for cpTM (diagonal)
+ cbar = plt.colorbar(im, ax=ax_in, fraction=0.046, pad=0.04)
+ cbar.ax.tick_params(labelsize=dyn_size_ch) # Set fontsize for colorbar labels
+ cbar.outline.set_edgecolor('grey')
+ cbar.outline.set_linewidth(0.5)
+
+ # Add text annotations
+ for i in range(data.shape[0]):
+ for j in range(data.shape[1]):
+ value = data.iloc[i, j]
+ if not mask_upper[i, j] and not mask_diagonal[i, j]:
+ text_color = 'white' if value > 0.8 else 'black'
+ ax_in.text(j, i, f"{value:.2f}", ha='center', va='center', color=text_color, fontsize=dyn_size_ch*1.2)
+ elif not mask_lower[i, j] and not mask_diagonal[i, j]:
+ text_color = 'white' if value > 0.8 else 'black'
+ ax_in.text(j, i, f"{value:.2f}", ha='center', va='center', color=text_color, fontsize=dyn_size_ch*1.2)
+ elif mask_diagonal[i, j]:
+ text_color = 'white' if value > 0.5 else 'black'
+ ax_in.text(j, i, f"{value:.2f}", ha='center', va='center', color=text_color, fontsize=dyn_size_ch*1.2)
+
+ # Custom colored legend (ifpTM, cpTM, ipTM)
+ x_start = 0.35
+ x_offset = 0.125
+ dyn_size = 16
+ ax_in.text(0.1, 1.05, prefix, fontsize=dyn_size, fontweight='bold', color='black', ha='center', transform=ax_in.transAxes)
+ ax_in.text(x_start + x_offset - 0.06, 1.05, 'actifpTM', fontsize=dyn_size, fontweight='bold', color='darkblue', ha='center', transform=ax_in.transAxes)
+ ax_in.text(x_start + 2 * x_offset, 1.05, ' - ', fontsize=dyn_size, fontweight='bold', color='black', ha='center', transform=ax_in.transAxes)
+ ax_in.text(x_start + 3 * x_offset, 1.05, 'cpTM', fontsize=dyn_size, fontweight='bold', color='dimgrey', ha='center', transform=ax_in.transAxes)
+ ax_in.text(x_start + 4 * x_offset, 1.05, ' - ', fontsize=dyn_size, fontweight='bold', color='black', ha='center', transform=ax_in.transAxes)
+ ax_in.text(x_start + 5 * x_offset, 1.05, 'ipTM', fontsize=dyn_size, fontweight='bold', color='firebrick', ha='center', transform=ax_in.transAxes)
+
+ # Format labels
+ ax_in.set_yticks(np.arange(len(letters)))
+ ax_in.set_yticklabels(letters, rotation=0, fontsize=dyn_size_ch*1.5)
+ ax_in.set_xticks(np.arange(len(letters)))
+ ax_in.set_xticklabels(letters, fontsize=dyn_size_ch*1.5)
+
+ # If this was only one plot, display and save it.
+ # If multiple plots have been appended, this needs to be done from the calling function
+ if not ax_in:
+ plt.tight_layout()
+ plt.savefig(fig_path, dpi=200, bbox_inches='tight')
+
+def plot_chain_pairwise_analysis(info, prefix='rank_', fig_path="chain_pairwise_ptm.png"):
+ from matplotlib import pyplot as plt
+ num_elements = len(info)
+ fig, axes = plt.subplots(1, num_elements, figsize=(num_elements * 5, 5), squeeze=False)
+
+ # We do this so that the same function can be used both for colabfold and colabdesign
+ for idx, ax in enumerate(axes[0]):
+ prefix_plot = prefix + str(idx+1)
+ if isinstance(info[idx], dict):
+ actifptm_dict = info[idx].get("pairwise_actifptm", {})
+ iptm_dict = info[idx].get("pairwise_iptm", {})
+ cptm_dict = info[idx].get("per_chain_ptm", {})
+ else:
+ actifptm_dict = info[idx][4]
+ iptm_dict = info[idx][3]
+ cptm_dict = info[idx][5]
+
+ plot_matrix(actifptm_dict, iptm_dict, cptm_dict, prefix=prefix_plot, ax_in=ax, fig_path=fig_path)
+
+ plt.tight_layout()
+ plt.savefig(fig_path, dpi=200, bbox_inches='tight')
+ plt.close(fig)
diff --git a/data/colabfold/alphafold/models.py b/data/colabfold/alphafold/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0899b0c5e0196843fe1ebbc2e99bbac9b4cb01b5
--- /dev/null
+++ b/data/colabfold/alphafold/models.py
@@ -0,0 +1,200 @@
+from pathlib import Path
+from functools import wraps, partialmethod
+from typing import Tuple, List, Optional
+import haiku
+from alphafold.model import model, config, data
+from alphafold.model.modules import AlphaFold
+from alphafold.model.modules_multimer import AlphaFold as AlphaFoldMultimer
+
+def get_model_haiku_params(
+ data_dir: str,
+ model_type: str,
+ model_number: str,
+ use_fuse: bool = True,
+ to_jnp: bool = True,
+) -> haiku.Params:
+ """Get the Haiku parameters from a model type and number."""
+ import os
+ import numpy as np
+ from alphafold.model import utils
+ import jax.numpy as jnp
+
+ is_deepfold = False
+ if model_type == "alphafold2_multimer_v1":
+ file = f"params_model_{model_number}_multimer.npz"
+ elif model_type == "alphafold2_multimer_v2":
+ file = f"params_model_{model_number}_multimer_v2.npz"
+ elif model_type == "alphafold2_multimer_v3":
+ file = f"params_model_{model_number}_multimer_v3.npz"
+ elif model_type == "alphafold2_ptm":
+ file = f"params_model_{model_number}_ptm.npz"
+ elif model_type == "alphafold2":
+ file = f"params_model_{model_number}.npz"
+ elif model_type == "deepfold_v1":
+ file = f"deepfold_model_{model_number}.npz"
+ is_deepfold = True
+ else:
+ raise ValueError(f"Unknown model_type {model_type}")
+
+ path = os.path.join(data_dir, "params", file)
+ params = np.load(path, allow_pickle=False)
+ return utils.flat_params_to_haiku(params, fuse=use_fuse, to_jnp=to_jnp)
+
+
+def model_to_config_name(model_type: str, model_number: str) -> str:
+ if model_type == "alphafold2_multimer_v1":
+ return f"model_{model_number}_multimer"
+ elif model_type == "alphafold2_multimer_v2":
+ return f"model_{model_number}_multimer_v2"
+ elif model_type == "alphafold2_multimer_v3":
+ return f"model_{model_number}_multimer_v3"
+ elif model_type == "alphafold2_ptm":
+ return f"model_{model_number}_ptm"
+ elif model_type == "alphafold2":
+ return f"model_{model_number}"
+ elif model_type == "deepfold_v1":
+ return f"model_{model_number}"
+ else:
+ raise ValueError(f"Unknown model_type {model_type}")
+
+
+def load_models_and_params(
+ num_models: int,
+ use_templates: bool,
+ num_recycles: Optional[int] = None,
+ recycle_early_stop_tolerance: Optional[float] = None,
+ num_ensemble: int = 1,
+ model_order: Optional[List[int]] = None,
+ model_type: str = "",
+ data_dir: Path = Path("."),
+ stop_at_score: float = 100,
+ rank_by: str = "auto",
+ max_seq: Optional[int] = None,
+ max_extra_seq: Optional[int] = None,
+ use_cluster_profile: bool = True,
+ use_fuse: bool = True,
+ use_bfloat16: bool = True,
+ use_dropout: bool = False,
+ save_all: bool = False,
+ calc_extra_ptm: bool = False,
+ use_probs_extra: bool = True
+) -> List[Tuple[str, model.RunModel, haiku.Params]]:
+ """We use only two actual models and swap the parameters to avoid recompiling.
+
+ Note that models 1 and 2 have a different number of parameters compared to models 3, 4 and 5,
+ so we load model 1 and model 3.
+ """
+
+ # Use only two model and later swap params to avoid recompiling
+ model_runner_and_params: [Tuple[str, model.RunModel, haiku.Params]] = []
+
+ if model_order is None:
+ model_order = [1, 2, 3, 4, 5]
+ else:
+ model_order.sort()
+
+ model_build_order = [3, 4, 5, 1, 2]
+ if "multimer" in model_type:
+ models_need_compilation = [3]
+ else:
+ # only models 1,2 use templates
+ models_need_compilation = [1, 3] if use_templates else [3]
+
+ model_runner_and_params_build_order: [Tuple[str, model.RunModel, haiku.Params]] = []
+ model_runner = None
+ for model_number in model_build_order:
+ if model_number in models_need_compilation:
+ # get configurations
+ config_name = model_to_config_name(model_type, model_number)
+ model_config = config.model_config(config_name)
+ model_config.model.stop_at_score = float(stop_at_score)
+ model_config.model.rank_by = rank_by
+
+ # set dropouts
+ model_config.model.global_config.eval_dropout = use_dropout
+
+ # set bfloat options
+ model_config.model.global_config.bfloat16 = use_bfloat16
+
+ # set fuse options
+ model_config.model.embeddings_and_evoformer.evoformer.triangle_multiplication_incoming.fuse_projection_weights = use_fuse
+ model_config.model.embeddings_and_evoformer.evoformer.triangle_multiplication_outgoing.fuse_projection_weights = use_fuse
+ if "multimer" in config_name or model_number in [1,2]:
+ model_config.model.embeddings_and_evoformer.template.template_pair_stack.triangle_multiplication_incoming.fuse_projection_weights = use_fuse
+ model_config.model.embeddings_and_evoformer.template.template_pair_stack.triangle_multiplication_outgoing.fuse_projection_weights = use_fuse
+
+ # set number of sequences options
+ if max_seq is not None:
+ if "multimer" in config_name:
+ model_config.model.embeddings_and_evoformer.num_msa = max_seq
+ else:
+ model_config.data.eval.max_msa_clusters = max_seq
+
+ if max_extra_seq is not None:
+ if "multimer" in config_name:
+ model_config.model.embeddings_and_evoformer.num_extra_msa = max_extra_seq
+ else:
+ model_config.data.common.max_extra_msa = max_extra_seq
+
+ # disable some outputs if not being saved
+ if not save_all:
+ if not calc_extra_ptm:
+ model_config.model.heads.distogram.weight = 0.0
+ model_config.model.heads.masked_msa.weight = 0.0
+ model_config.model.heads.experimentally_resolved.weight = 0.0
+
+ # set number of recycles and ensembles
+ if "multimer" in config_name:
+ if num_recycles is not None:
+ model_config.model.num_recycle = num_recycles
+ model_config.model.embeddings_and_evoformer.use_cluster_profile = use_cluster_profile
+ model_config.model.num_ensemble_eval = num_ensemble
+ else:
+ if num_recycles is not None:
+ model_config.data.common.num_recycle = num_recycles
+ model_config.model.num_recycle = num_recycles
+ model_config.data.eval.num_ensemble = num_ensemble
+
+ if recycle_early_stop_tolerance is not None:
+ model_config.model.recycle_early_stop_tolerance = recycle_early_stop_tolerance
+
+ # get model runner
+ params = get_model_haiku_params(
+ model_type=model_type,
+ model_number=model_number,
+ data_dir=str(data_dir),
+ use_fuse=use_fuse
+ )
+
+ model_runner = model.RunModel(
+ model_config,
+ params,
+ extended_ptm_config={'calc_extended_ptm': calc_extra_ptm,
+ 'use_probs_extended': use_probs_extra}
+ )
+
+ params = get_model_haiku_params(
+ model_type=model_type,
+ model_number=model_number,
+ data_dir=str(data_dir),
+ use_fuse=use_fuse,
+ )
+ # keep only parameters of compiled model
+ params_subset = {}
+ for k in model_runner.params.keys():
+ params_subset[k] = params[k]
+
+ model_name = f"model_{model_number}"
+ model_runner_and_params_build_order.append(
+ (model_name, model_runner, params_subset)
+ )
+ # reorder model
+ for n, model_number in enumerate(model_order):
+ if n == num_models:
+ break
+ model_name = f"model_{model_number}"
+ for m in model_runner_and_params_build_order:
+ if model_name == m[0]:
+ model_runner_and_params.append(m)
+ break
+ return model_runner_and_params
diff --git a/data/colabfold/alphafold/msa.py b/data/colabfold/alphafold/msa.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a9086a9fa8f7ed9d8c8a0b6bd38c2d9bcb8e1ac
--- /dev/null
+++ b/data/colabfold/alphafold/msa.py
@@ -0,0 +1,44 @@
+from typing import Mapping, Any
+import numpy as np
+
+from alphafold.model.features import FeatureDict
+from alphafold.model.tf import shape_placeholders
+
+NUM_RES = shape_placeholders.NUM_RES
+NUM_MSA_SEQ = shape_placeholders.NUM_MSA_SEQ
+NUM_EXTRA_SEQ = shape_placeholders.NUM_EXTRA_SEQ
+NUM_TEMPLATES = shape_placeholders.NUM_TEMPLATES
+
+def make_fixed_size(
+ feat: Mapping[str, Any],
+ shape_schema,
+ msa_cluster_size: int,
+ extra_msa_size: int,
+ num_res: int,
+ num_templates: int = 0,
+) -> FeatureDict:
+ """Guess at the MSA and sequence dimensions to make fixed size."""
+ pad_size_map = {
+ NUM_RES: num_res,
+ NUM_MSA_SEQ: msa_cluster_size,
+ NUM_EXTRA_SEQ: extra_msa_size,
+ NUM_TEMPLATES: num_templates,
+ }
+ for k, v in feat.items():
+ # Don't transfer this to the accelerator.
+ if k == "extra_cluster_assignment":
+ continue
+ shape = list(v.shape)
+
+ schema = shape_schema[k]
+
+ assert len(shape) == len(schema), (
+ f"Rank mismatch between shape and shape schema for {k}: "
+ f"{shape} vs {schema}"
+ )
+ pad_size = [pad_size_map.get(s2, None) or s1 for (s1, s2) in zip(shape, schema)]
+ padding = [(0, p - v.shape[i]) for i, p in enumerate(pad_size)]
+
+ if padding:
+ feat[k] = np.pad(v, padding)
+ return feat
\ No newline at end of file
diff --git a/data/colabfold/batch.py b/data/colabfold/batch.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7ba7fc5c1390ea6e6c034af659d400e09068f91
--- /dev/null
+++ b/data/colabfold/batch.py
@@ -0,0 +1,2255 @@
+from __future__ import annotations
+
+import os
+ENV = {"TF_FORCE_UNIFIED_MEMORY":"1", "XLA_PYTHON_CLIENT_MEM_FRACTION":"4.0"}
+for k,v in ENV.items():
+ if k not in os.environ: os.environ[k] = v
+
+import warnings
+from Bio import BiopythonDeprecationWarning # what can possibly go wrong...
+warnings.simplefilter(action='ignore', category=BiopythonDeprecationWarning)
+
+import json
+hasOrjson = False
+try:
+ import orjson
+ hasOrjson = True
+except ImportError:
+ pass
+import logging
+import math
+import sys
+import time
+import zipfile
+import shutil
+import pickle
+import gzip
+
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from io import StringIO
+
+import importlib_metadata
+import numpy as np
+
+try:
+ import alphafold
+except ModuleNotFoundError:
+ raise RuntimeError(
+ "\n\nalphafold is not installed. Please run `pip install colabfold[alphafold]`\n"
+ )
+
+from alphafold.common import protein, residue_constants
+
+# delay imports of tensorflow, jax and numpy
+# loading these for type checking only can take around 10 seconds just to show a CLI usage message
+if TYPE_CHECKING:
+ import haiku
+ from alphafold.model import model
+ from numpy import ndarray
+
+from alphafold.common.protein import Protein
+from alphafold.data import (
+ feature_processing,
+ msa_pairing,
+ pipeline,
+ pipeline_multimer,
+ templates,
+)
+from alphafold.data.tools import hhsearch
+from colabfold.citations import write_bibtex
+from colabfold.download import default_data_dir, download_alphafold_params
+from colabfold.utils import (
+ ACCEPT_DEFAULT_TERMS,
+ DEFAULT_API_SERVER,
+ NO_GPU_FOUND,
+ CIF_REVISION_DATE,
+ get_commit,
+ setup_logging,
+ CFMMCIFIO,
+ AF3Utils,
+)
+from colabfold.input import (
+ pair_msa,
+ msa_to_str,
+ get_queries,
+ safe_filename,
+ modified_mapping,
+ pdb_to_string,
+)
+from colabfold.relax import relax_me
+from colabfold.alphafold import extra_ptm
+
+from Bio.PDB import MMCIFParser, PDBParser, MMCIF2Dict
+from Bio.PDB.PDBIO import Select
+
+# logging settings
+logger = logging.getLogger(__name__)
+from jax import local_devices
+
+# from jax 0.4.6, jax._src.lib.xla_bridge moved to jax._src.xla_bridge
+# suppress warnings: Unable to initialize backend 'rocm' or 'tpu'
+logging.getLogger('jax._src.xla_bridge').addFilter(lambda _: False) # jax >=0.4.6
+logging.getLogger('jax._src.lib.xla_bridge').addFilter(lambda _: False) # jax < 0.4.5
+
+def mk_mock_template(
+ query_sequence: Union[List[str], str], num_temp: int = 1
+) -> Dict[str, Any]:
+ ln = (
+ len(query_sequence)
+ if isinstance(query_sequence, str)
+ else sum(len(s) for s in query_sequence)
+ )
+ output_templates_sequence = "A" * ln
+ output_confidence_scores = np.full(ln, 1.0)
+
+ templates_all_atom_positions = np.zeros(
+ (ln, templates.residue_constants.atom_type_num, 3)
+ )
+ templates_all_atom_masks = np.zeros((ln, templates.residue_constants.atom_type_num))
+ templates_aatype = templates.residue_constants.sequence_to_onehot(
+ output_templates_sequence, templates.residue_constants.HHBLITS_AA_TO_ID
+ )
+ template_features = {
+ "template_all_atom_positions": np.tile(
+ templates_all_atom_positions[None], [num_temp, 1, 1, 1]
+ ),
+ "template_all_atom_masks": np.tile(
+ templates_all_atom_masks[None], [num_temp, 1, 1]
+ ),
+ "template_sequence": [f"none".encode()] * num_temp,
+ "template_aatype": np.tile(np.array(templates_aatype)[None], [num_temp, 1, 1]),
+ "template_confidence_scores": np.tile(
+ output_confidence_scores[None], [num_temp, 1]
+ ),
+ "template_domain_names": [f"none".encode()] * num_temp,
+ "template_release_date": [f"none".encode()] * num_temp,
+ "template_sum_probs": np.zeros([num_temp], dtype=np.float32),
+ }
+ return template_features
+
+def mk_template(
+ a3m_lines: str,
+ template_path: str,
+ query_sequence: str,
+ max_template_date="2100-01-01",
+ max_hits=20,
+) -> Dict[str, Any]:
+ template_featurizer = templates.HhsearchHitFeaturizer(
+ mmcif_dir=template_path,
+ max_template_date=max_template_date,
+ max_hits=max_hits,
+ kalign_binary_path="kalign",
+ release_dates_path=None,
+ obsolete_pdbs_path=None,
+ )
+
+ hhsearch_pdb70_runner = hhsearch.HHSearch(
+ binary_path="hhsearch", databases=[f"{template_path}/pdb70"]
+ )
+
+ hhsearch_result = hhsearch_pdb70_runner.query(a3m_lines)
+ hhsearch_hits = pipeline.parsers.parse_hhr(hhsearch_result)
+ templates_result = template_featurizer.get_templates(
+ query_sequence=query_sequence, hits=hhsearch_hits
+ )
+ return dict(templates_result.features)
+
+def validate_and_fix_mmcif(cif_file: Path):
+ """validate presence of _entity_poly_seq in cif file and add revision_date if missing"""
+ # check that required poly_seq and revision_date fields are present
+ cif_dict = MMCIF2Dict.MMCIF2Dict(cif_file)
+ required = [
+ "_chem_comp.id",
+ "_chem_comp.type",
+ "_struct_asym.id",
+ "_struct_asym.entity_id",
+ "_entity_poly_seq.mon_id",
+ ]
+ for r in required:
+ if r not in cif_dict:
+ raise ValueError(f"mmCIF file {cif_file} is missing required field {r}.")
+ if "_pdbx_audit_revision_history.revision_date" not in cif_dict:
+ logger.info(
+ f"Adding missing field revision_date to {cif_file}. Backing up original file to {cif_file}.bak."
+ )
+ shutil.copy2(cif_file, str(cif_file) + ".bak")
+ with open(cif_file, "a") as f:
+ f.write(CIF_REVISION_DATE)
+
+class ReplaceOrRemoveHetatmSelect(Select):
+ def accept_residue(self, residue):
+ hetfield, _, _ = residue.get_id()
+ if hetfield != " ":
+ if residue.resname in modified_mapping:
+ # set unmodified resname
+ residue.resname = modified_mapping[residue.resname]
+ # clear hetatm flag
+ residue._id = (" ", residue._id[1], " ")
+ t = residue.full_id
+ residue.full_id = (t[0], t[1], t[2], residue._id)
+ return 1
+ return 0
+ else:
+ return 1
+
+def convert_pdb_to_mmcif(pdb_file: Path):
+ """convert existing pdb files into mmcif with the required poly_seq and revision_date"""
+ i = pdb_file.stem
+ cif_file = pdb_file.parent.joinpath(f"{i}.cif")
+ if cif_file.is_file():
+ return
+ parser = PDBParser(QUIET=True)
+ structure = parser.get_structure(i, pdb_file)
+ cif_io = CFMMCIFIO()
+ cif_io.set_structure(structure)
+ cif_io.save(str(cif_file), ReplaceOrRemoveHetatmSelect())
+
+def mk_hhsearch_single_entry_db(cif_file: Path, dbdir_cache_path: str):
+ dbdir = Path(dbdir_cache_path)
+ dbdir.mkdir(parents=True, exist_ok=True)
+ tmp_cif_path = str(dbdir_cache_path) + "/1dmy.cif"
+ shutil.copy2(cif_file, tmp_cif_path)
+ # clear internal AF2 cache of mmCIF files
+ templates._read_file.cache_clear()
+ cif_file = Path(tmp_cif_path)
+ pdb70_db_files = dbdir.glob("pdb70*")
+ for f in pdb70_db_files:
+ os.remove(f)
+
+ with open(dbdir.joinpath("pdb70_a3m.ffdata"), "w") as a3m, open(
+ dbdir.joinpath("pdb70_cs219.ffindex"), "w"
+ ) as cs219_index, open(
+ dbdir.joinpath("pdb70_a3m.ffindex"), "w"
+ ) as a3m_index, open(
+ dbdir.joinpath("pdb70_cs219.ffdata"), "w"
+ ) as cs219:
+ n = 1000000
+ index_offset = 0
+ with open(cif_file) as f:
+ cif_string = f.read()
+ cif_fh = StringIO(cif_string)
+ parser = MMCIFParser(QUIET=True)
+ structure = parser.get_structure("none", cif_fh)
+ models = list(structure.get_models())
+ if len(models) != 1:
+ logger.warning(f"WARNING: Found {len(models)} models in {cif_file}. The first model will be used as a template.", )
+ # raise ValueError(
+ # f"Only single model PDBs are supported. Found {len(models)} models in {cif_file}."
+ # )
+ model = models[0]
+ for chain in model:
+ amino_acid_res = []
+ for res in chain:
+ if res.id[2] != " ":
+ logger.warning(f"WARNING: Found insertion code at chain {chain.id} and residue index {res.id[1]} of {cif_file}. "
+ "This file cannot be used as a template.")
+ continue
+ # raise ValueError(
+ # f"PDB {cif_file} contains an insertion code at chain {chain.id} and residue "
+ # f"index {res.id[1]}. These are not supported."
+ # )
+ amino_acid_res.append(
+ residue_constants.restype_3to1.get(res.resname, "X")
+ )
+
+ protein_str = "".join(amino_acid_res)
+ a3m_str = f">{cif_file.stem}_{chain.id}\n{protein_str}\n\0"
+ a3m_str_len = len(a3m_str)
+ a3m_index.write(f"{n}\t{index_offset}\t{a3m_str_len}\n")
+ cs219_index.write(f"{n}\t{index_offset}\t{len(protein_str)}\n")
+ index_offset += a3m_str_len
+ a3m.write(a3m_str)
+ cs219.write("\n\0")
+ n += 1
+
+def mk_hhsearch_db(template_dir: str):
+ template_path = Path(template_dir)
+
+ cif_files = template_path.glob("*.cif")
+ for cif_file in cif_files:
+ validate_and_fix_mmcif(cif_file)
+
+ pdb_files = template_path.glob("*.pdb")
+ for pdb_file in pdb_files:
+ convert_pdb_to_mmcif(pdb_file)
+
+ pdb70_db_files = template_path.glob("pdb70*")
+ for f in pdb70_db_files:
+ os.remove(f)
+
+ with open(template_path.joinpath("pdb70_a3m.ffdata"), "w") as a3m, open(
+ template_path.joinpath("pdb70_cs219.ffindex"), "w"
+ ) as cs219_index, open(
+ template_path.joinpath("pdb70_a3m.ffindex"), "w"
+ ) as a3m_index, open(
+ template_path.joinpath("pdb70_cs219.ffdata"), "w"
+ ) as cs219:
+ n = 1000000
+ index_offset = 0
+ cif_files = template_path.glob("*.cif")
+ for cif_file in cif_files:
+ with open(cif_file) as f:
+ cif_string = f.read()
+ cif_fh = StringIO(cif_string)
+ parser = MMCIFParser(QUIET=True)
+ structure = parser.get_structure("none", cif_fh)
+ models = list(structure.get_models())
+ if len(models) != 1:
+ logger.warning(f"WARNING: Found {len(models)} models in {cif_file}. The first model will be used as a template.", )
+ # raise ValueError(
+ # f"Only single model PDBs are supported. Found {len(models)} models in {cif_file}."
+ # )
+ model = models[0]
+ for chain in model:
+ amino_acid_res = []
+ for res in chain:
+ if res.id[2] != " ":
+ logger.warning(f"WARNING: Found insertion code at chain {chain.id} and residue index {res.id[1]} of {cif_file}. "
+ "This file cannot be used as a template.")
+ continue
+ # raise ValueError(
+ # f"PDB {cif_file} contains an insertion code at chain {chain.id} and residue "
+ # f"index {res.id[1]}. These are not supported."
+ # )
+ amino_acid_res.append(
+ residue_constants.restype_3to1.get(res.resname, "X")
+ )
+
+ protein_str = "".join(amino_acid_res)
+ a3m_str = f">{cif_file.stem}_{chain.id}\n{protein_str}\n\0"
+ a3m_str_len = len(a3m_str)
+ a3m_index.write(f"{n}\t{index_offset}\t{a3m_str_len}\n")
+ cs219_index.write(f"{n}\t{index_offset}\t{len(protein_str)}\n")
+ index_offset += a3m_str_len
+ a3m.write(a3m_str)
+ cs219.write("\n\0")
+ n += 1
+
+def pad_input(
+ input_features: model.features.FeatureDict,
+ model_runner: model.RunModel,
+ model_name: str,
+ pad_len: int,
+ use_templates: bool,
+) -> model.features.FeatureDict:
+ from colabfold.alphafold.msa import make_fixed_size
+
+ model_config = model_runner.config
+ eval_cfg = model_config.data.eval
+ crop_feats = {k: [None] + v for k, v in dict(eval_cfg.feat).items()}
+
+ max_msa_clusters = eval_cfg.max_msa_clusters
+ max_extra_msa = model_config.data.common.max_extra_msa
+ # templates models
+ if (model_name == "model_1" or model_name == "model_2") and use_templates:
+ pad_msa_clusters = max_msa_clusters - eval_cfg.max_templates
+ else:
+ pad_msa_clusters = max_msa_clusters
+
+ max_msa_clusters = pad_msa_clusters
+
+ # let's try pad (num_res + X)
+ input_fix = make_fixed_size(
+ input_features,
+ crop_feats,
+ msa_cluster_size=max_msa_clusters, # true_msa (4, 512, 68)
+ extra_msa_size=max_extra_msa, # extra_msa (4, 5120, 68)
+ num_res=pad_len, # aatype (4, 68)
+ num_templates=4,
+ ) # template_mask (4, 4) second value
+ return input_fix
+
+class file_manager:
+ def __init__(self, prefix: str, result_dir: Path):
+ self.prefix = prefix
+ self.result_dir = result_dir
+ self.tag = None
+ self.files = {}
+
+ def get(self, x: str, ext:str) -> Path:
+ if self.tag not in self.files:
+ self.files[self.tag] = []
+ file = self.result_dir.joinpath(f"{self.prefix}_{x}_{self.tag}.{ext}")
+ self.files[self.tag].append([x,ext,file])
+ return file
+
+ def set_tag(self, tag):
+ self.tag = tag
+
+def predict_structure(
+ prefix: str,
+ result_dir: Path,
+ feature_dict: Dict[str, Any],
+ is_complex: bool,
+ use_templates: bool,
+ sequences_lengths: List[int],
+ pad_len: int,
+ model_type: str,
+ model_runner_and_params: List[Tuple[str, model.RunModel, haiku.Params]],
+ initial_guess: str = None,
+ num_relax: int = 0,
+ relax_max_iterations: int = 0,
+ relax_tolerance: float = 2.39,
+ relax_stiffness: float = 10.0,
+ relax_max_outer_iterations: int = 3,
+ rank_by: str = "auto",
+ random_seed: int = 0,
+ num_seeds: int = 1,
+ stop_at_score: float = 100,
+ prediction_callback: Callable[[Any, Any, Any, Any, Any], Any] = None,
+ use_gpu_relax: bool = False,
+ save_all: bool = False,
+ save_single_representations: bool = False,
+ save_pair_representations: bool = False,
+ save_recycles: bool = False,
+ calc_extra_ptm: bool = False,
+ use_probs_extra: bool = True,
+):
+ """Predicts structure using AlphaFold for the given sequence."""
+ mean_scores = []
+ conf = []
+ unrelaxed_pdb_lines = []
+ prediction_times = []
+ model_names = []
+ files = file_manager(prefix, result_dir)
+ seq_len = sum(sequences_lengths)
+
+ # iterate through random seeds
+ for seed_num, seed in enumerate(range(random_seed, random_seed+num_seeds)):
+
+ # iterate through models
+ for model_num, (model_name, model_runner, params) in enumerate(model_runner_and_params):
+
+ # swap params to avoid recompiling
+ model_runner.params = params
+
+ #########################
+ # process input features
+ #########################
+ if "multimer" in model_type:
+ if model_num == 0 and seed_num == 0:
+ # TODO: add pad_input_mulitmer()
+ input_features = feature_dict
+ input_features["asym_id"] = input_features["asym_id"] - input_features["asym_id"][...,0]
+ else:
+ if model_num == 0:
+ input_features = model_runner.process_features(feature_dict, random_seed=seed)
+ r = input_features["aatype"].shape[0]
+ input_features["asym_id"] = np.tile(feature_dict["asym_id"],r).reshape(r,-1)
+ if seq_len < pad_len:
+ input_features = pad_input(input_features, model_runner,
+ model_name, pad_len, use_templates)
+ logger.info(f"Padding length to {pad_len}")
+
+
+ tag = f"{model_type}_{model_name}_seed_{seed:03d}"
+ model_names.append(tag)
+ files.set_tag(tag)
+
+ # initial guess
+ if initial_guess:
+ input_guess = Path(initial_guess)
+ if input_guess.suffix == ".pdb":
+ pdb_string = pdb_to_string(initial_guess)
+ input_features["all_atom_positions"] = protein.from_pdb_string(pdb_string).atom_positions
+ elif input_guess.suffix == ".cif":
+ input_features["all_atom_positions"] = protein.from_mmcif_string(input_guess.read_text()).atom_positions
+ else:
+ raise ValueError(f"Unsupported initial guess file format: {initial_guess}")
+
+
+ ########################
+ # predict
+ ########################
+ start = time.time()
+
+ # monitor intermediate results
+ def callback(result, recycles):
+ if recycles == 0: result.pop("tol",None)
+ if not is_complex: result.pop("iptm",None)
+ print_line = ""
+ for x,y in [["mean_plddt","pLDDT"],["ptm","pTM"],["iptm","ipTM"],["tol","tol"]]:
+ if x in result:
+ print_line += f" {y}={result[x]:.3g}"
+ logger.info(f"{tag} recycle={recycles}{print_line}")
+
+ if save_recycles:
+ final_atom_mask = result["structure_module"]["final_atom_mask"]
+ b_factors = result["plddt"][:, None] * final_atom_mask
+ unrelaxed_protein = protein.from_prediction(
+ features=input_features,
+ result=result, b_factors=b_factors,
+ remove_leading_feature_dimension=("multimer" not in model_type))
+ files.get("unrelaxed",f"r{recycles}.pdb").write_text(protein.to_pdb(unrelaxed_protein))
+
+ if save_all:
+ with files.get("all",f"r{recycles}.pickle").open("wb") as handle:
+ pickle.dump(result, handle)
+ del unrelaxed_protein
+
+ return_representations = save_all or save_single_representations or save_pair_representations
+
+ # predict
+ result, recycles = \
+ model_runner.predict(input_features,
+ random_seed=seed,
+ return_representations=return_representations,
+ callback=callback)
+
+ if calc_extra_ptm and 'predicted_aligned_error' in result.keys():
+ extra_ptm_output = extra_ptm.get_chain_and_interface_metrics(result, input_features['asym_id'],
+ use_probs_extra=use_probs_extra,
+ use_jnp=False)
+ result.pop('pae_matrix_with_logits', None)
+ result['actifptm'] = extra_ptm_output['actifptm']
+ else:
+ calc_extra_ptm = False
+ prediction_times.append(time.time() - start)
+
+ ########################
+ # parse results
+ ########################
+
+ # summary metrics
+ mean_scores.append(result["ranking_confidence"])
+ if recycles == 0: result.pop("tol",None)
+ if not is_complex: result.pop("iptm",None)
+ print_line = ""
+ conf.append({})
+ for x,y in [["mean_plddt","pLDDT"],["ptm","pTM"],["iptm","ipTM"], ['actifptm', 'actifpTM']]:
+ if x in result:
+ print_line += f" {y}={result[x]:.3g}"
+ conf[-1][x] = float(result[x])
+ conf[-1]["print_line"] = print_line
+ logger.info(f"{tag} took {prediction_times[-1]:.1f}s ({recycles} recycles)")
+
+ # create protein object
+ final_atom_mask = result["structure_module"]["final_atom_mask"]
+ b_factors = result["plddt"][:, None] * final_atom_mask
+ unrelaxed_protein = protein.from_prediction(
+ features=input_features,
+ result=result,
+ b_factors=b_factors,
+ remove_leading_feature_dimension=("multimer" not in model_type))
+
+ # callback for visualization
+ if prediction_callback is not None:
+ prediction_callback(unrelaxed_protein, sequences_lengths,
+ result, input_features, (tag, False))
+
+ #########################
+ # save results
+ #########################
+
+ # save pdb
+ protein_lines = protein.to_pdb(unrelaxed_protein)
+ files.get("unrelaxed","pdb").write_text(protein_lines)
+ unrelaxed_pdb_lines.append(protein_lines)
+
+ # save raw outputs
+ if save_all:
+ with files.get("all","pickle").open("wb") as handle:
+ pickle.dump(result, handle)
+ if save_single_representations:
+ np.save(files.get("single_repr","npy"),result["representations"]["single"])
+ if save_pair_representations:
+ np.save(files.get("pair_repr","npy"),result["representations"]["pair"])
+
+ # write an easy-to-use format (pAE and pLDDT)
+ plddt = result["plddt"][:seq_len]
+ scores = {"plddt": np.around(plddt.astype(float), 2).tolist()}
+ if "predicted_aligned_error" in result:
+ pae = result["predicted_aligned_error"][:seq_len,:seq_len]
+ scores.update({"max_pae": pae.max().astype(float).item(),
+ "pae": np.around(pae.astype(float), 2).tolist()})
+ if calc_extra_ptm:
+ scores.update(extra_ptm_output)
+ for k in ["ptm", "iptm"]:
+ if k in conf[-1]:
+ scores[k] = np.around(conf[-1][k], 2).item()
+ del pae
+ del plddt
+ file = files.get("scores", "json")
+ if hasOrjson:
+ file.write_bytes(orjson.dumps(scores))
+ else:
+ file.write_text(json.dumps(scores))
+
+ del result, unrelaxed_protein
+
+ # early stop criteria fulfilled
+ if mean_scores[-1] > stop_at_score: break
+
+ # early stop criteria fulfilled
+ if mean_scores[-1] > stop_at_score: break
+
+ # cleanup
+ if "multimer" not in model_type: del input_features
+ if "multimer" in model_type: del input_features
+
+ ###################################################
+ # rerank models based on predicted confidence
+ ###################################################
+
+ rank, metric = [],[]
+ result_files = []
+ logger.info(f"reranking models by '{rank_by}' metric")
+ model_rank = np.array(mean_scores).argsort()[::-1]
+ for n, key in enumerate(model_rank):
+ metric.append(conf[key])
+ tag = model_names[key]
+ files.set_tag(tag)
+ # save relaxed pdb
+ if n < num_relax:
+ start = time.time()
+ pdb_lines = relax_me(
+ pdb_lines=unrelaxed_pdb_lines[key],
+ max_iterations=relax_max_iterations,
+ tolerance=relax_tolerance,
+ stiffness=relax_stiffness,
+ max_outer_iterations=relax_max_outer_iterations,
+ use_gpu=use_gpu_relax)
+ files.get("relaxed","pdb").write_text(pdb_lines)
+ logger.info(f"Relaxation took {(time.time() - start):.1f}s")
+
+ # rename files to include rank
+ new_tag = f"rank_{(n+1):03d}_{tag}"
+ rank.append(new_tag)
+ logger.info(f"{new_tag}{metric[-1]['print_line']}")
+ for x, ext, file in files.files[tag]:
+ new_file = result_dir.joinpath(f"{prefix}_{x}_{new_tag}.{ext}")
+ file.rename(new_file)
+ result_files.append(new_file)
+
+ return {"rank":rank,
+ "metric":metric,
+ "result_files":result_files}
+
+def get_msa_and_templates(
+ jobname: str,
+ query_sequences: Union[str, List[str]],
+ a3m_lines: Optional[List[str]],
+ result_dir: Path,
+ msa_mode: str,
+ use_templates: bool,
+ custom_template_path: str,
+ pair_mode: str,
+ pairing_strategy: str = "greedy",
+ host_url: str = DEFAULT_API_SERVER,
+ user_agent: str = "",
+ max_template_date="2100-01-01",
+ max_template_hits=20,
+) -> Tuple[
+ Optional[List[str]], Optional[List[str]], List[str], List[int], List[Dict[str, Any]]
+]:
+ from colabfold.colabfold import run_mmseqs2
+
+ use_env = msa_mode == "mmseqs2_uniref_env" or msa_mode == "mmseqs2_uniref_env_envpair"
+ use_envpair = msa_mode == "mmseqs2_uniref_env_envpair"
+ if isinstance(query_sequences, str): query_sequences = [query_sequences]
+
+ # remove duplicates before searching
+ query_seqs_unique = []
+ for x in query_sequences:
+ if x not in query_seqs_unique:
+ query_seqs_unique.append(x)
+
+ # determine how many times is each sequence is used
+ query_seqs_cardinality = [0] * len(query_seqs_unique)
+ for seq in query_sequences:
+ seq_idx = query_seqs_unique.index(seq)
+ query_seqs_cardinality[seq_idx] += 1
+
+ # get template features
+ template_features = []
+ if use_templates:
+ # Skip template search when custom_template_path is provided
+ if custom_template_path is not None:
+ if msa_mode == "single_sequence":
+ a3m_lines = []
+ num = 101
+ for i, seq in enumerate(query_seqs_unique):
+ a3m_lines.append(f">{num + i}\n{seq}")
+
+ if a3m_lines is None:
+ a3m_lines_mmseqs2 = run_mmseqs2(
+ query_seqs_unique,
+ str(result_dir.joinpath(jobname)),
+ use_env,
+ use_templates=False,
+ host_url=host_url,
+ user_agent=user_agent,
+ )
+ else:
+ a3m_lines_mmseqs2 = a3m_lines
+ template_paths = {}
+ for index in range(0, len(query_seqs_unique)):
+ template_paths[index] = custom_template_path
+ else:
+ a3m_lines_mmseqs2, template_paths = run_mmseqs2(
+ query_seqs_unique,
+ str(result_dir.joinpath(jobname)),
+ use_env,
+ use_templates=True,
+ host_url=host_url,
+ user_agent=user_agent,
+ )
+ if template_paths is None:
+ logger.info("No template detected")
+ for index in range(0, len(query_seqs_unique)):
+ template_feature = mk_mock_template(query_seqs_unique[index])
+ template_features.append(template_feature)
+ else:
+ for index in range(0, len(query_seqs_unique)):
+ if template_paths[index] is not None:
+ template_feature = mk_template(
+ a3m_lines_mmseqs2[index],
+ template_paths[index],
+ query_seqs_unique[index],
+ max_template_date=max_template_date,
+ max_hits=max_template_hits,
+ )
+ if len(template_feature["template_domain_names"]) == 0:
+ template_feature = mk_mock_template(query_seqs_unique[index])
+ logger.info(f"Sequence {index} found no templates")
+ else:
+ logger.info(
+ f"Sequence {index} found templates: {template_feature['template_domain_names'].astype(str).tolist()}"
+ )
+ else:
+ template_feature = mk_mock_template(query_seqs_unique[index])
+ logger.info(f"Sequence {index} found no templates")
+
+ template_features.append(template_feature)
+ else:
+ for index in range(0, len(query_seqs_unique)):
+ template_feature = mk_mock_template(query_seqs_unique[index])
+ template_features.append(template_feature)
+
+ if len(query_sequences) == 1:
+ pair_mode = "none"
+
+ if pair_mode == "none" or pair_mode == "unpaired" or pair_mode == "unpaired_paired":
+ if msa_mode == "single_sequence":
+ a3m_lines = []
+ num = 101
+ for i, seq in enumerate(query_seqs_unique):
+ a3m_lines.append(f">{num + i}\n{seq}")
+ else:
+ # find normal a3ms
+ a3m_lines = run_mmseqs2(
+ query_seqs_unique,
+ str(result_dir.joinpath(jobname)),
+ use_env,
+ use_pairing=False,
+ host_url=host_url,
+ user_agent=user_agent,
+ )
+ else:
+ a3m_lines = None
+
+ if msa_mode != "single_sequence" and (
+ pair_mode == "paired" or pair_mode == "unpaired_paired"
+ ):
+ # find paired a3m if not a homooligomers
+ if len(query_seqs_unique) > 1:
+ paired_a3m_lines = run_mmseqs2(
+ query_seqs_unique,
+ str(result_dir.joinpath(jobname)),
+ use_envpair,
+ use_pairing=True,
+ pairing_strategy=pairing_strategy,
+ host_url=host_url,
+ user_agent=user_agent,
+ )
+ else:
+ # homooligomers
+ num = 101
+ paired_a3m_lines = []
+ for i in range(0, query_seqs_cardinality[0]):
+ paired_a3m_lines.append(f">{num+i}\n{query_seqs_unique[0]}\n")
+ else:
+ paired_a3m_lines = None
+
+ return (
+ a3m_lines,
+ paired_a3m_lines,
+ query_seqs_unique,
+ query_seqs_cardinality,
+ template_features,
+ )
+
+def build_monomer_feature(
+ sequence: str, unpaired_msa: str, template_features: Dict[str, Any]
+):
+ msa = pipeline.parsers.parse_a3m(unpaired_msa)
+ # gather features
+ return {
+ **pipeline.make_sequence_features(
+ sequence=sequence, description="none", num_res=len(sequence)
+ ),
+ **pipeline.make_msa_features([msa]),
+ **template_features,
+ }
+
+def build_multimer_feature(paired_msa: str) -> Dict[str, ndarray]:
+ parsed_paired_msa = pipeline.parsers.parse_a3m(paired_msa)
+ return {
+ f"{k}_all_seq": v
+ for k, v in pipeline.make_msa_features([parsed_paired_msa]).items()
+ }
+
+def process_multimer_features(
+ features_for_chain: Dict[str, Dict[str, ndarray]],
+ min_num_seq: int = 512,
+) -> Dict[str, ndarray]:
+ all_chain_features = {}
+ for chain_id, chain_features in features_for_chain.items():
+ all_chain_features[chain_id] = pipeline_multimer.convert_monomer_features(
+ chain_features, chain_id
+ )
+
+ all_chain_features = pipeline_multimer.add_assembly_features(all_chain_features)
+ # np_example = feature_processing.pair_and_merge(
+ # all_chain_features=all_chain_features, is_prokaryote=is_prokaryote)
+ feature_processing.process_unmerged_features(all_chain_features)
+ np_chains_list = list(all_chain_features.values())
+ # noinspection PyProtectedMember
+ pair_msa_sequences = not feature_processing._is_homomer_or_monomer(np_chains_list)
+ chains = list(np_chains_list)
+ chain_keys = chains[0].keys()
+ updated_chains = []
+ for chain_num, chain in enumerate(chains):
+ new_chain = {k: v for k, v in chain.items() if "_all_seq" not in k}
+ for feature_name in chain_keys:
+ if feature_name.endswith("_all_seq"):
+ feats_padded = msa_pairing.pad_features(
+ chain[feature_name], feature_name
+ )
+ new_chain[feature_name] = feats_padded
+ new_chain["num_alignments_all_seq"] = np.asarray(
+ len(np_chains_list[chain_num]["msa_all_seq"])
+ )
+ updated_chains.append(new_chain)
+ np_chains_list = updated_chains
+ np_chains_list = feature_processing.crop_chains(
+ np_chains_list,
+ msa_crop_size=feature_processing.MSA_CROP_SIZE,
+ pair_msa_sequences=pair_msa_sequences,
+ max_templates=feature_processing.MAX_TEMPLATES,
+ )
+ # merge_chain_features crashes if there are additional features only present in one chain
+ # remove all features that are not present in all chains
+ common_features = set([*np_chains_list[0]]).intersection(*np_chains_list)
+ np_chains_list = [
+ {key: value for (key, value) in chain.items() if key in common_features}
+ for chain in np_chains_list
+ ]
+ np_example = feature_processing.msa_pairing.merge_chain_features(
+ np_chains_list=np_chains_list,
+ pair_msa_sequences=pair_msa_sequences,
+ max_templates=feature_processing.MAX_TEMPLATES,
+ )
+ np_example = feature_processing.process_final(np_example)
+
+ # Pad MSA to avoid zero-sized extra_msa.
+ np_example = pipeline_multimer.pad_msa(np_example, min_num_seq=min_num_seq)
+ return np_example
+
+def generate_input_feature(
+ query_seqs_unique: List[str],
+ query_seqs_cardinality: List[int],
+ unpaired_msa: List[str],
+ paired_msa: List[str],
+ template_features: List[Dict[str, Any]],
+ is_complex: bool,
+ model_type: str,
+ max_seq: int,
+) -> Tuple[Dict[str, Any], Dict[str, str]]:
+
+ input_feature = {}
+ domain_names = {}
+ if is_complex and "multimer" not in model_type:
+
+ full_sequence = ""
+ Ls = []
+ for sequence_index, sequence in enumerate(query_seqs_unique):
+ for cardinality in range(0, query_seqs_cardinality[sequence_index]):
+ full_sequence += sequence
+ Ls.append(len(sequence))
+
+ # bugfix
+ a3m_lines = f">0\n{full_sequence}\n"
+ a3m_lines += pair_msa(query_seqs_unique, query_seqs_cardinality, paired_msa, unpaired_msa)
+
+ input_feature = build_monomer_feature(full_sequence, a3m_lines, mk_mock_template(full_sequence))
+ input_feature["residue_index"] = np.concatenate([np.arange(L) for L in Ls])
+ input_feature["asym_id"] = np.concatenate([np.full(L,n) for n,L in enumerate(Ls)])
+ if any(
+ [
+ template != b"none"
+ for i in template_features
+ for template in i["template_domain_names"]
+ ]
+ ):
+ logger.warning(
+ f"{model_type} complex does not consider templates. Chose multimer model-type for template support."
+ )
+
+ else:
+ features_for_chain = {}
+ chain_cnt = 0
+ # for each unique sequence
+ for sequence_index, sequence in enumerate(query_seqs_unique):
+
+ # get unpaired msa
+ if unpaired_msa is None:
+ input_msa = f">{101 + sequence_index}\n{sequence}"
+ else:
+ input_msa = unpaired_msa[sequence_index]
+
+ feature_dict = build_monomer_feature(
+ sequence, input_msa, template_features[sequence_index])
+
+ if "multimer" in model_type:
+ # get paired msa
+ if paired_msa is None:
+ input_msa = f">{101 + sequence_index}\n{sequence}"
+ else:
+ input_msa = paired_msa[sequence_index]
+ feature_dict.update(build_multimer_feature(input_msa))
+
+ # for each copy
+ for cardinality in range(0, query_seqs_cardinality[sequence_index]):
+ features_for_chain[protein.PDB_CHAIN_IDS[chain_cnt]] = feature_dict
+ chain_cnt += 1
+
+ if "multimer" in model_type:
+ # combine features across all chains
+ input_feature = process_multimer_features(features_for_chain, min_num_seq=max_seq + 4)
+ domain_names = {
+ chain: [
+ name.decode("UTF-8")
+ for name in feature["template_domain_names"]
+ if name != b"none"
+ ]
+ for (chain, feature) in features_for_chain.items()
+ }
+ else:
+ input_feature = features_for_chain[protein.PDB_CHAIN_IDS[0]]
+ input_feature["asym_id"] = np.zeros(input_feature["aatype"].shape[0],dtype=int)
+ domain_names = {
+ protein.PDB_CHAIN_IDS[0]: [
+ name.decode("UTF-8")
+ for name in input_feature["template_domain_names"]
+ if name != b"none"
+ ]
+ }
+ return (input_feature, domain_names)
+
+def normalize_a3m(lines: list[str]) -> list[str]:
+ out = []
+ i = 0
+
+ # keep meta header
+ if lines and lines[0].startswith("#"):
+ out.append(lines[0].rstrip("\n"))
+ i = 1
+
+ header = None
+ seq_chunks = []
+ while i < len(lines):
+ line = lines[i].strip()
+ i += 1
+ if not line:
+ continue
+ if line.startswith(">"):
+ if header is not None:
+ out.append(header)
+ out.append("".join(seq_chunks))
+ header = line
+ seq_chunks = []
+ else:
+ # remove all whitespace inside sequence lines
+ seq_chunks.append("".join(line.split()))
+ if header is not None:
+ out.append(header)
+ out.append("".join(seq_chunks))
+
+ return out
+
+def unserialize_msa(
+ a3m_lines: List[str], query_sequence: Union[List[str], str]
+) -> Tuple[
+ Optional[List[str]],
+ Optional[List[str]],
+ List[str],
+ List[int],
+ List[Dict[str, Any]],
+]:
+ a3m_lines = a3m_lines[0].replace("\x00", "").splitlines()
+ a3m_lines = normalize_a3m(a3m_lines)
+ if not a3m_lines[0].startswith("#") or len(a3m_lines[0][1:].split("\t")) != 2:
+ assert isinstance(query_sequence, str)
+ return (
+ ["\n".join(a3m_lines)],
+ None,
+ [query_sequence],
+ [1],
+ [mk_mock_template(query_sequence)],
+ )
+
+ if len(a3m_lines) < 3:
+ raise ValueError(f"Unknown file format a3m")
+ tab_sep_entries = a3m_lines[0][1:].split("\t")
+ query_seq_len = tab_sep_entries[0].split(",")
+ query_seq_len = list(map(int, query_seq_len))
+ query_seqs_cardinality = tab_sep_entries[1].split(",")
+ query_seqs_cardinality = list(map(int, query_seqs_cardinality))
+ num_chains = len(query_seq_len)
+ is_homooligomer = (
+ True if num_chains == 1 and query_seqs_cardinality[0] > 1 else False
+ )
+ is_single_protein = (
+ True if num_chains == 1 and query_seqs_cardinality[0] == 1 else False
+ )
+
+ query_seqs_unique = []
+ qcat = a3m_lines[2]
+ prev = 0
+ for qlen in query_seq_len:
+ nxt = prev + max(int(qlen), 0)
+ query_seqs_unique.append(qcat[prev:nxt])
+ prev = nxt
+
+ paired_chunks = [[] for _ in range(num_chains)]
+ unpaired_chunks = [[] for _ in range(num_chains)]
+ already_in = set()
+
+ qlens_local = query_seq_len
+ def _split_by_aln(s):
+ segments = [""] * num_chains
+ has_aa = [False] * num_chains
+ seg_idx = 0
+ aln_count = 0
+ start = 0
+ curr_has_aa = False
+
+ dash = '-'
+ A, Z = 'A', 'Z'
+ a, z = 'a', 'z'
+ n = len(s)
+ i = 0
+ while i < n and seg_idx < num_chains:
+ c = s[i]
+ # non-lowercase are aligned columns
+ if not (a <= c <= z):
+ if c != dash and (A <= c <= Z):
+ curr_has_aa = True
+ aln_count += 1
+ if aln_count == qlens_local[seg_idx]:
+ # close current segment
+ segments[seg_idx] = s[start:i+1]
+ has_aa[seg_idx] = curr_has_aa
+ seg_idx += 1
+ aln_count = 0
+ start = i + 1
+ curr_has_aa = False
+ i += 1
+ return segments, has_aa
+
+ i = 1
+ end = len(a3m_lines)
+ while i + 1 < end:
+ header = a3m_lines[i]
+ seq = a3m_lines[i + 1]
+ i += 2
+
+ key = (header, seq)
+ if key in already_in:
+ continue
+ already_in.add(key)
+
+ segments, has_aa = _split_by_aln(seq)
+
+ # Paired if multi-chain (not single protein), not homo-oligomer, >=2 segments have AA
+ if (not is_single_protein) and (not is_homooligomer) and (sum(has_aa) > 1):
+ header_no_gt = header.replace(">", "")
+ header_fields = header_no_gt.split("\t")
+ for j, seg in enumerate(segments):
+ label = header_fields[j] if j < len(header_fields) else (header_fields[-1] if header_fields else "")
+ pc = paired_chunks[j]
+ pc.append(">")
+ pc.append(label)
+ pc.append("\n")
+ pc.append(seg)
+ pc.append("\n")
+ else:
+ for j, seg in enumerate(segments):
+ if has_aa[j]:
+ uc = unpaired_chunks[j]
+ uc.append(header)
+ uc.append("\n")
+ uc.append(seg)
+ uc.append("\n")
+
+ if is_homooligomer:
+ num = 101
+ count = max(query_seqs_cardinality[0], 0)
+ q = query_seqs_unique[0] if query_seqs_unique else ""
+ paired_msa = [f">{num + k}\n{q}\n" for k in range(count)]
+ else:
+ if is_single_protein:
+ paired_msa = None
+ else:
+ paired_msa = ["".join(ch) for ch in paired_chunks]
+
+
+ unpaired_msa = ["".join(ch) for ch in unpaired_chunks]
+ template_features = [mk_mock_template(q) for q in query_seqs_unique]
+
+ return (
+ unpaired_msa,
+ paired_msa,
+ query_seqs_unique,
+ query_seqs_cardinality,
+ template_features,
+ )
+
+def put_mmciffiles_into_resultdir(
+ pdb_hit_file: Path,
+ local_pdb_path: Path,
+ result_dir: Path,
+ max_num_templates: int = 20,
+):
+ """Put mmcif files from local_pdb_path into result_dir and unzip them.
+ max_num_templates is the maximum number of templates to use (default: 20).
+ Args:
+ pdb_hit_file (Path): Path to pdb_hit_file
+ local_pdb_path (Path): Path to local_pdb_path
+ result_dir (Path): Path to result_dir
+ max_num_templates (int): Maximum number of templates to use
+ """
+ pdb_hit_file = Path(pdb_hit_file)
+ local_pdb_path = Path(local_pdb_path)
+ result_dir = Path(result_dir)
+ result_dir.mkdir(parents=True, exist_ok=True)
+
+ query_ids = []
+ with open(pdb_hit_file, "r") as f:
+ for line in f:
+ query_id = line.split("\t")[0]
+ query_ids.append(query_id)
+ if query_ids.count(query_id) > max_num_templates:
+ continue
+ else:
+ pdb_id = line.split("\t")[1][0:4]
+ divided_pdb_id = pdb_id[1:3]
+ gzipped_divided_mmcif_file = local_pdb_path / divided_pdb_id / (pdb_id + ".cif.gz")
+ gzipped_mmcif_file = local_pdb_path / (pdb_id + ".cif.gz")
+ unzipped_mmcif_file = local_pdb_path / (pdb_id + ".cif")
+ result_file = result_dir / (pdb_id + ".cif")
+ possible_files = [gzipped_divided_mmcif_file, gzipped_mmcif_file, unzipped_mmcif_file]
+ for file in possible_files:
+ if file == gzipped_divided_mmcif_file or file == gzipped_mmcif_file:
+ if file.exists():
+ with gzip.open(file, "rb") as f_in:
+ with open(result_file, "wb") as f_out:
+ shutil.copyfileobj(f_in, f_out)
+ break
+ else:
+ # unzipped_mmcif_file
+ if file.exists():
+ shutil.copyfile(file, result_file)
+ break
+ if not result_file.exists():
+ print(f"WARNING: {pdb_id} does not exist in {local_pdb_path}.")
+
+
+def run(
+ queries: List[Tuple[str, Union[str, List[str]], Optional[List[str]], Optional[List[Tuple[str, str,int]]]]],
+ result_dir: Union[str, Path],
+ num_models: int,
+ is_complex: bool,
+ num_recycles: Optional[int] = None,
+ recycle_early_stop_tolerance: Optional[float] = None,
+ model_order: List[int] = [1,2,3,4,5],
+ initial_guess: str = None,
+ num_ensemble: int = 1,
+ model_type: str = "auto",
+ msa_mode: str = "mmseqs2_uniref_env",
+ use_templates: bool = False,
+ custom_template_path: str = None,
+ custom_template_cache_path: str = None,
+ num_relax: int = 0,
+ relax_max_iterations: int = 0,
+ relax_tolerance: float = 2.39,
+ relax_stiffness: float = 10.0,
+ relax_max_outer_iterations: int = 3,
+ keep_existing_results: bool = True,
+ rank_by: str = "auto",
+ pair_mode: str = "unpaired_paired",
+ pairing_strategy: str = "greedy",
+ data_dir: Union[str, Path] = default_data_dir,
+ host_url: str = DEFAULT_API_SERVER,
+ user_agent: str = "",
+ random_seed: int = 0,
+ num_seeds: int = 1,
+ recompile_padding: Union[int, float] = 10,
+ zip_results: bool = False,
+ prediction_callback: Callable[[Any, Any, Any, Any, Any], Any] = None,
+ save_single_representations: bool = False,
+ save_pair_representations: bool = False,
+ skip_output: List[str] = [],
+ jobname_prefix: Optional[str] = None,
+ save_all: bool = False,
+ save_recycles: bool = False,
+ use_dropout: bool = False,
+ use_gpu_relax: bool = False,
+ stop_at_score: float = 100,
+ dpi: int = 200,
+ max_seq: Optional[int] = None,
+ max_extra_seq: Optional[int] = None,
+ pdb_hit_file: Optional[Path] = None,
+ local_pdb_path: Optional[Path] = None,
+ use_cluster_profile: bool = True,
+ feature_dict_callback: Callable[[Any], Any] = None,
+ calc_extra_ptm: bool = False,
+ use_probs_extra: bool = True,
+ max_template_date: str = "2100-01-01",
+ max_template_hits: int = 20,
+ **kwargs
+):
+ # check what device is available
+ try:
+ # check if TPU is available
+ from tpu_info import device
+ if len(device.get_local_chips()) > 0:
+ import jax.tools.colab_tpu
+ jax.tools.colab_tpu.setup_tpu()
+ logger.info('Running on TPU')
+ use_gpu_relax = False
+ except:
+ if local_devices()[0].platform == 'cpu':
+ logger.info("WARNING: no GPU detected, will be using CPU")
+ use_gpu_relax = False
+ else:
+ import tensorflow as tf
+ tf.get_logger().setLevel(logging.ERROR)
+ logger.info('Running on GPU')
+ # disable GPU on tensorflow
+ tf.config.set_visible_devices([], 'GPU')
+
+ from colabfold.alphafold.models import load_models_and_params
+
+ data_dir = Path(data_dir)
+ result_dir = Path(result_dir)
+ result_dir.mkdir(exist_ok=True)
+ model_type = set_model_type(is_complex, model_type)
+
+ # backward-compatibility with old options
+ old_names = {"MMseqs2 (UniRef+Environmental)":"mmseqs2_uniref_env",
+ "MMseqs2 (UniRef+Environmental+Env. Pairing)":"mmseqs2_uniref_env_envpair",
+ "MMseqs2 (UniRef only)":"mmseqs2_uniref",
+ "unpaired+paired":"unpaired_paired"}
+ msa_mode = old_names.get(msa_mode,msa_mode)
+ pair_mode = old_names.get(pair_mode,pair_mode)
+ feature_dict_callback = kwargs.pop("input_features_callback", feature_dict_callback)
+ use_dropout = kwargs.pop("training", use_dropout)
+ use_fuse = kwargs.pop("use_fuse", True)
+ use_bfloat16 = kwargs.pop("use_bfloat16", True)
+ max_msa = kwargs.pop("max_msa",None)
+ if max_msa is not None:
+ max_seq, max_extra_seq = [int(x) for x in max_msa.split(":")]
+
+ if kwargs.pop("use_amber", False) and num_relax == 0:
+ num_relax = num_models * num_seeds
+
+ if len(kwargs) > 0:
+ print(f"WARNING: the following options are not being used: {kwargs}")
+
+ # decide how to rank outputs
+ if rank_by == "auto":
+ rank_by = "multimer" if is_complex else "plddt"
+ if "ptm" not in model_type and "multimer" not in model_type:
+ rank_by = "plddt"
+
+ # added for actifptm calculation
+ if not is_complex and calc_extra_ptm:
+ logger.info("Calculating extra pTM is not supported for single chain prediction, skipping it.")
+ calc_extra_ptm = False
+
+ # get max length
+ max_len = 0
+ max_num = 0
+ for _, query_sequence, _, _ in queries:
+ N = 1 if isinstance(query_sequence,str) else len(query_sequence)
+ L = len("".join(query_sequence))
+ if L > max_len: max_len = L
+ if N > max_num: max_num = N
+
+ # get max sequences
+ # 512 5120 = alphafold_ptm (models 1,3,4)
+ # 512 1024 = alphafold_ptm (models 2,5)
+ # 508 2048 = alphafold-multimer_v3 (models 1,2,3)
+ # 508 1152 = alphafold-multimer_v3 (models 4,5)
+ # 252 1152 = alphafold-multimer_v[1,2]
+
+ set_if = lambda x,y: y if x is None else x
+ if model_type in ["alphafold2_multimer_v1","alphafold2_multimer_v2"]:
+ (max_seq, max_extra_seq) = (set_if(max_seq,252), set_if(max_extra_seq,1152))
+ elif model_type == "alphafold2_multimer_v3":
+ (max_seq, max_extra_seq) = (set_if(max_seq,508), set_if(max_extra_seq,2048))
+ else:
+ (max_seq, max_extra_seq) = (set_if(max_seq,512), set_if(max_extra_seq,5120))
+
+ if msa_mode == "single_sequence":
+ num_seqs = 1
+ if is_complex and "multimer" not in model_type: num_seqs += max_num
+ if use_templates: num_seqs += 4
+ max_seq = min(num_seqs, max_seq)
+ max_extra_seq = max(min(num_seqs - max_seq, max_extra_seq), 1)
+
+ # sort model order
+ model_order.sort()
+
+ # initial guess
+ if initial_guess is not None:
+ logger.info(f'Using initial guess: {initial_guess}')
+
+ # Record the parameters of this run
+ config = {
+ "num_queries": len(queries),
+ "use_templates": use_templates,
+ "num_relax": num_relax,
+ "relax_max_iterations": relax_max_iterations,
+ "relax_tolerance": relax_tolerance,
+ "relax_stiffness": relax_stiffness,
+ "relax_max_outer_iterations": relax_max_outer_iterations,
+ "msa_mode": msa_mode,
+ "model_type": model_type,
+ "num_models": num_models,
+ "num_recycles": num_recycles,
+ "recycle_early_stop_tolerance": recycle_early_stop_tolerance,
+ "num_ensemble": num_ensemble,
+ "model_order": model_order,
+ "initial_guess": initial_guess,
+ "keep_existing_results": keep_existing_results,
+ "rank_by": rank_by,
+ "max_seq": max_seq,
+ "max_extra_seq": max_extra_seq,
+ "pair_mode": pair_mode,
+ "pairing_strategy": pairing_strategy,
+ "host_url": host_url,
+ "user_agent": user_agent,
+ "stop_at_score": stop_at_score,
+ "random_seed": random_seed,
+ "num_seeds": num_seeds,
+ "recompile_padding": recompile_padding,
+ "commit": get_commit(),
+ "use_dropout": use_dropout,
+ "use_cluster_profile": use_cluster_profile,
+ "use_fuse": use_fuse,
+ "use_bfloat16": use_bfloat16,
+ "version": importlib_metadata.version("colabfold"),
+ "calc_extra_ptm": calc_extra_ptm,
+ "use_probs_extra": use_probs_extra,
+ "max_template_date": max_template_date,
+ "max_template_hits": max_template_hits,
+ }
+ config_out_file = result_dir.joinpath("config.json")
+ config_out_file.write_text(json.dumps(config, indent=4))
+ use_env = "env" in msa_mode
+ use_msa = "mmseqs2" in msa_mode
+ use_amber = num_models > 0 and num_relax > 0
+
+ bibtex_file = write_bibtex(
+ model_type if num_models > 0 else "", use_msa, use_env, use_templates, use_amber, result_dir
+ )
+
+ if pdb_hit_file is not None:
+ if local_pdb_path is None:
+ raise ValueError("local_pdb_path is not specified.")
+ else:
+ custom_template_path = result_dir / "templates"
+ put_mmciffiles_into_resultdir(pdb_hit_file, local_pdb_path, custom_template_path)
+
+
+ if custom_template_path is not None:
+ mk_hhsearch_db(custom_template_path)
+
+ pad_len = 0
+ ranks, metrics = [],[]
+ first_job = True
+ job_number = 0
+ for job_number, (raw_jobname, query_sequence, a3m_lines, custom_template_path_per_entry) in enumerate(queries):
+
+ if use_templates and custom_template_path_per_entry is not None and isinstance(custom_template_path_per_entry, Path):
+ mk_hhsearch_single_entry_db(custom_template_path_per_entry, custom_template_cache_path)
+ custom_template_path = custom_template_cache_path
+
+ if jobname_prefix is not None:
+ # pad job number based on number of queries
+ fill = len(str(len(queries)))
+ jobname = safe_filename(jobname_prefix) + "_" + str(job_number).zfill(fill)
+ job_number += 1
+ else:
+ jobname = safe_filename(raw_jobname)
+
+ #######################################
+ # check if job has already finished
+ #######################################
+ # In the colab version and with --zip we know we're done when a zip file has been written
+ result_zip = result_dir.joinpath(jobname).with_suffix(".result.zip")
+ if keep_existing_results and result_zip.is_file():
+ logger.info(f"Skipping {jobname} (result.zip)")
+ continue
+ # In the local version we use a marker file
+ is_done_marker = result_dir.joinpath(jobname + ".done.txt")
+ if keep_existing_results and is_done_marker.is_file():
+ logger.info(f"Skipping {jobname} (already done)")
+ continue
+
+ seq_len = len("".join(query_sequence))
+ logger.info(f"Query {job_number + 1}/{len(queries)}: {jobname} (length {seq_len})")
+
+ ###########################################
+ # generate MSA (a3m_lines) and templates
+ ###########################################
+ try:
+ pickled_msa_and_templates = result_dir.joinpath(f"{jobname}.pickle")
+ if pickled_msa_and_templates.is_file():
+ with open(pickled_msa_and_templates, 'rb') as f:
+ (unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality, template_features) = pickle.load(f)
+ logger.info(f"Loaded {pickled_msa_and_templates}")
+
+ else:
+ if a3m_lines is None:
+ (unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality, template_features) \
+ = get_msa_and_templates(
+ jobname, query_sequence, a3m_lines, result_dir, msa_mode, use_templates,
+ custom_template_path, pair_mode, pairing_strategy, host_url, user_agent,
+ max_template_date=max_template_date, max_template_hits=max_template_hits,
+ )
+
+ elif a3m_lines is not None:
+ if(isinstance(a3m_lines, Path)):
+ a3m_lines = [a3m_lines.read_text()]
+ (unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality, template_features) \
+ = unserialize_msa(a3m_lines, query_sequence)
+ if use_templates:
+ (_, _, _, _, template_features) \
+ = get_msa_and_templates(
+ jobname, query_seqs_unique, unpaired_msa, result_dir, 'single_sequence', use_templates,
+ custom_template_path, pair_mode, pairing_strategy, host_url, user_agent,
+ max_template_date=max_template_date, max_template_hits=max_template_hits,
+ )
+
+ if num_models == 0:
+ with open(pickled_msa_and_templates, 'wb') as f:
+ pickle.dump((unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality, template_features), f)
+ logger.info(f"Saved {pickled_msa_and_templates}")
+
+ # save a3m
+ if not 'msa' in skip_output:
+ msa = msa_to_str(unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality)
+ result_dir.joinpath(f"{jobname}.a3m").write_text(msa)
+
+ except Exception as e:
+ logger.exception(f"Could not get MSA/templates for {jobname}: {e}")
+ continue
+
+ #######################
+ # generate features
+ #######################
+ try:
+ (feature_dict, domain_names) \
+ = generate_input_feature(query_seqs_unique, query_seqs_cardinality, unpaired_msa, paired_msa,
+ template_features, is_complex, model_type, max_seq=max_seq)
+
+ # to allow display of MSA info during colab/chimera run (thanks tomgoddard)
+ if feature_dict_callback is not None:
+ feature_dict_callback(feature_dict)
+
+ except Exception as e:
+ logger.exception(f"Could not generate input features {jobname}: {e}")
+ continue
+
+ ###############
+ # save plots not requiring prediction
+ ###############
+
+ result_files = []
+
+ # make msa plot
+ if not 'plots' in skip_output:
+ from colabfold.plot import plot_msa_v2
+ msa_plot = plot_msa_v2(feature_dict, dpi=dpi)
+ coverage_png = result_dir.joinpath(f"{jobname}_coverage.png")
+ msa_plot.savefig(str(coverage_png), bbox_inches='tight')
+ msa_plot.close()
+ result_files.append(coverage_png)
+
+ if use_templates:
+ templates_file = result_dir.joinpath(f"{jobname}_template_domain_names.json")
+ templates_file.write_text(json.dumps(domain_names))
+ result_files.append(templates_file)
+
+ result_files.append(result_dir.joinpath(jobname + ".a3m"))
+ result_files += [bibtex_file, config_out_file]
+
+ ######################
+ # predict structures
+ ######################
+ if num_models > 0:
+ try:
+ # get list of lengths
+ query_sequence_len_array = sum([[len(x)] * y
+ for x,y in zip(query_seqs_unique, query_seqs_cardinality)],[])
+
+ # decide how much to pad (to avoid recompiling)
+ if seq_len > pad_len:
+ if isinstance(recompile_padding, float):
+ pad_len = math.ceil(seq_len * recompile_padding)
+ else:
+ pad_len = seq_len + recompile_padding
+ pad_len = min(pad_len, max_len)
+
+ # prep model and params
+ if first_job:
+ # if one job input adjust max settings
+ if len(queries) == 1 and msa_mode != "single_sequence":
+ # get number of sequences
+ if "msa_mask" in feature_dict:
+ num_seqs = int(sum(feature_dict["msa_mask"].max(-1) == 1))
+ else:
+ num_seqs = int(len(feature_dict["msa"]))
+
+ if use_templates: num_seqs += 4
+
+ # adjust max settings
+ max_seq = min(num_seqs, max_seq)
+ max_extra_seq = max(min(num_seqs - max_seq, max_extra_seq), 1)
+ logger.info(f"Setting max_seq={max_seq}, max_extra_seq={max_extra_seq}")
+
+ model_runner_and_params = load_models_and_params(
+ num_models=num_models,
+ use_templates=use_templates,
+ num_recycles=num_recycles,
+ num_ensemble=num_ensemble,
+ model_order=model_order,
+ model_type=model_type,
+ data_dir=data_dir,
+ stop_at_score=stop_at_score,
+ rank_by=rank_by,
+ use_dropout=use_dropout,
+ max_seq=max_seq,
+ max_extra_seq=max_extra_seq,
+ use_cluster_profile=use_cluster_profile,
+ recycle_early_stop_tolerance=recycle_early_stop_tolerance,
+ use_fuse=use_fuse,
+ use_bfloat16=use_bfloat16,
+ save_all=save_all,
+ calc_extra_ptm=calc_extra_ptm
+ )
+ first_job = False
+
+ results = predict_structure(
+ prefix=jobname,
+ result_dir=result_dir,
+ feature_dict=feature_dict,
+ is_complex=is_complex,
+ use_templates=use_templates,
+ sequences_lengths=query_sequence_len_array,
+ pad_len=pad_len,
+ initial_guess=initial_guess,
+ model_type=model_type,
+ model_runner_and_params=model_runner_and_params,
+ num_relax=num_relax,
+ relax_max_iterations=relax_max_iterations,
+ relax_tolerance=relax_tolerance,
+ relax_stiffness=relax_stiffness,
+ relax_max_outer_iterations=relax_max_outer_iterations,
+ rank_by=rank_by,
+ stop_at_score=stop_at_score,
+ prediction_callback=prediction_callback,
+ use_gpu_relax=use_gpu_relax,
+ random_seed=random_seed,
+ num_seeds=num_seeds,
+ save_all=save_all,
+ save_single_representations=save_single_representations,
+ save_pair_representations=save_pair_representations,
+ save_recycles=save_recycles,
+ calc_extra_ptm=calc_extra_ptm,
+ use_probs_extra=use_probs_extra,
+ )
+
+ result_files += results["result_files"]
+ ranks.append(results["rank"])
+ metrics.append(results["metric"])
+
+ except RuntimeError as e:
+ # This normally happens on OOM. TODO: Filter for the specific OOM error message
+ logger.error(f"Could not predict {jobname}. Not Enough GPU memory? {e}")
+ continue
+
+ ###############
+ # save prediction plots
+ ###############
+
+ # load the scores
+ if not 'pae_json' in skip_output:
+ scores = []
+ for r in results["rank"][:5]:
+ scores_file = result_dir.joinpath(f"{jobname}_scores_{r}.json")
+ with scores_file.open("r") as handle:
+ scores.append(json.load(handle))
+
+ # write alphafold-db format (pAE)
+ if "pae" in scores[0]:
+ af_pae_file = result_dir.joinpath(f"{jobname}_predicted_aligned_error_v1.json")
+ af_pae_file.write_text(json.dumps({
+ "predicted_aligned_error":scores[0]["pae"],
+ "max_predicted_aligned_error":scores[0]["max_pae"]}))
+ result_files.append(af_pae_file)
+
+ # make pAE plots
+ if not 'plots' in skip_output:
+ from colabfold.colabfold import plot_paes
+ paes_plot = plot_paes([np.asarray(x["pae"]) for x in scores],
+ Ls=query_sequence_len_array, dpi=dpi)
+ pae_png = result_dir.joinpath(f"{jobname}_pae.png")
+ paes_plot.savefig(str(pae_png), bbox_inches='tight')
+ paes_plot.close()
+ result_files.append(pae_png)
+
+ # make pairwise interface metric plots and chainwise ptm plot
+ if calc_extra_ptm:
+ ext_metric_png = result_dir.joinpath(f"{jobname}_ext_metrics.png")
+ extra_ptm.plot_chain_pairwise_analysis(scores, fig_path=ext_metric_png)
+
+ # make pLDDT plot
+ if not 'plots' in skip_output:
+ from colabfold.colabfold import plot_plddts
+ plddt_plot = plot_plddts([np.asarray(x["plddt"]) for x in scores],
+ Ls=query_sequence_len_array, dpi=dpi)
+ plddt_png = result_dir.joinpath(f"{jobname}_plddt.png")
+ plddt_plot.savefig(str(plddt_png), bbox_inches='tight')
+ plddt_plot.close()
+ result_files.append(plddt_png)
+
+ if zip_results:
+ with zipfile.ZipFile(result_zip, "w") as result_zip:
+ for file in result_files:
+ result_zip.write(file, arcname=file.name)
+
+ # Delete only after the zip was successful, and also not the bibtex and config because we need those again
+ for file in result_files:
+ if file != bibtex_file and file != config_out_file:
+ file.unlink()
+ else:
+ if num_models > 0:
+ is_done_marker.touch()
+
+ logger.info("Done")
+ return {"rank":ranks,"metric":metrics}
+
+def set_model_type(is_complex: bool, model_type: str) -> str:
+ # backward-compatibility with old options
+ old_names = {
+ "AlphaFold2-multimer-v1":"alphafold2_multimer_v1",
+ "AlphaFold2-multimer-v2":"alphafold2_multimer_v2",
+ "AlphaFold2-multimer-v3":"alphafold2_multimer_v3",
+ "AlphaFold2-ptm": "alphafold2_ptm",
+ "AlphaFold2": "alphafold2",
+ "DeepFold": "deepfold_v1",
+ }
+ model_type = old_names.get(model_type, model_type)
+ if model_type == "auto":
+ if is_complex:
+ model_type = "alphafold2_multimer_v3"
+ else:
+ model_type = "alphafold2_ptm"
+ return model_type
+
+def generate_af3_input(
+ queries: List[Tuple[str, Union[str, List[str]], Optional[List[str]], Optional[List[Tuple[str, str, int]]]]],
+ result_dir: Union[str, Path],
+ msa_mode: str = "mmseqs2_uniref_env",
+ pair_mode: str = "unpaired_paired",
+ pairing_strategy: str = "greedy",
+ use_templates: bool = False,
+ custom_template_path: str = None,
+ jobname_prefix: Optional[str] = None,
+ host_url: str = DEFAULT_API_SERVER,
+ user_agent: str = "",
+ max_template_date: str = "2100-01-01",
+ max_template_hits: int = 20,
+ # is_complex: bool,
+ # model_type: str = "auto",
+):
+ result_dir = Path(result_dir)
+ result_dir.mkdir(exist_ok=True)
+
+ job_number = 0
+
+ for job_number, (raw_jobname, query_sequences, a3m_lines, other_molecules) in enumerate(queries):
+ if jobname_prefix is not None:
+ # pad job number based on number of queries
+ fill = len(str(len(queries)))
+ jobname = safe_filename(jobname_prefix) + "_" + str(job_number).zfill(fill)
+ # job_number += 1 # Why add?
+ else:
+ jobname = safe_filename(raw_jobname)
+
+ ###########################################
+ # generate MSA (a3m_lines) and templates
+ ###########################################
+ try:
+ if a3m_lines is None:
+ (unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality, template_features) \
+ = get_msa_and_templates(
+ jobname, query_sequences, a3m_lines, result_dir, msa_mode, use_templates,
+ custom_template_path, pair_mode, pairing_strategy, host_url, user_agent,
+ max_template_date=max_template_date, max_template_hits=max_template_hits,
+ )
+
+ elif a3m_lines is not None:
+ (unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality, template_features) \
+ = unserialize_msa(a3m_lines, query_sequences)
+ # if use_templates:
+ # (_, _, _, _, template_features) \
+ # = get_msa_and_templates(
+ # jobname, query_seqs_unique, unpaired_msa, result_dir, 'single_sequence', use_templates,
+ # custom_template_path, pair_mode, pairing_strategy, host_url, user_agent,
+ # max_template_date=max_template_date, max_template_hits=max_template_hits,
+ # )
+
+ # save json
+ af3 = AF3Utils(jobname, query_seqs_unique, query_seqs_cardinality, unpaired_msa, paired_msa, other_molecules)
+ with open(result_dir.joinpath(f"{jobname}.json"), "w") as f:
+ f.write(json.dumps(af3.content, indent = 4))
+
+ # save a3m
+ msa = msa_to_str(unpaired_msa, paired_msa, query_seqs_unique, query_seqs_cardinality)
+ result_dir.joinpath(f"{jobname}.a3m").write_text(msa)
+
+ except Exception as e:
+ logger.exception(f"Failed to generate AF3 input json for {jobname}: Could not get MSA/templates. {e}")
+ continue
+
+def main():
+ parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
+ parser.add_argument(
+ "input",
+ default="input",
+ help="One of: 1) directory with FASTA/A3M files, 2) CSV/TSV file, 3) FASTA file or 4) A3M file.",
+ )
+ parser.add_argument("results", help="Results output directory.")
+
+ msa_group = parser.add_argument_group("MSA arguments", "")
+ msa_group.add_argument(
+ "--msa-only",
+ action="store_true",
+ help="Query and store MSAs from the MSA server without structure prediction",
+ )
+ msa_group.add_argument(
+ "--msa-mode",
+ default="mmseqs2_uniref_env",
+ choices=[
+ "mmseqs2_uniref_env",
+ "mmseqs2_uniref_env_envpair",
+ "mmseqs2_uniref",
+ "single_sequence",
+ ],
+ help="Databases to use to create the MSA: UniRef30+Environmental (default), UniRef30 only or None. "
+ "Using an A3M file as input overwrites this option.",
+ )
+ msa_group.add_argument(
+ "--pair-mode",
+ help="Multimer MSA pairing mode for complex prediction: unpaired MSA only, paired MSA only, both (default).",
+ type=str,
+ default="unpaired_paired",
+ choices=["unpaired", "paired", "unpaired_paired"],
+ )
+ msa_group.add_argument(
+ "--pair-strategy",
+ help="How sequences are paired during MSA pairing for complex prediction. "
+ "complete: MSA sequences should only be paired if the same species exists in all MSAs. "
+ "greedy: MSA sequences should only be paired if the same species exists in at least two MSAs. "
+ "Typically, greedy produces better predictions as it results in more paired sequences. "
+ "However, in some cases complete pairing might help, especially if MSAs are already large and can be well paired. ",
+ type=str,
+ default="greedy",
+ choices=["complete", "greedy"],
+ )
+ msa_group.add_argument(
+ "--templates",
+ default=False,
+ action="store_true",
+ help="Query PDB templates from the MSA server. "
+ 'If this parameter is not set, "--custom-template-path" and "--pdb-hit-file" will not be used. '
+ "Warning: This can result in the MSA server being queried with A3M input. "
+ )
+ msa_group.add_argument(
+ "--custom-template-path",
+ type=str,
+ default=None,
+ help="Directory with PDB files to provide as custom templates to the predictor. "
+ "No templates will be queried from the MSA server. "
+ "'--templates' argument is also required to enable this.",
+ )
+ msa_group.add_argument(
+ "--custom-template-cache-path",
+ type=str,
+ default=None,
+ help="Directory to generate temporary HHsearch databases for custom templates.",
+ )
+ msa_group.add_argument(
+ "--max-template-date",
+ type=str,
+ default="2100-01-01",
+ help="Maximum release date (YYYY-MM-DD) for templates to be considered."
+ )
+ msa_group.add_argument(
+ "--max-template-hits",
+ type=int,
+ default=20,
+ help="Maximum number of template hits to consider."
+ )
+ msa_group.add_argument(
+ "--pdb-hit-file",
+ default=None,
+ help="Path to a BLAST-m8 formatted PDB hit file corresponding to the input A3M file (e.g. pdb70.m8). "
+ "Typically, this parameter should be used for a MSA generated by 'colabfold_search'. "
+ "'--templates' argument is also required to enable this.",
+ )
+ msa_group.add_argument(
+ "--local-pdb-path",
+ default=None,
+ help="Directory of a local mirror of the PDB mmCIF database (e.g. /path/to/pdb/divided). "
+ "If provided, PDB files from the directory are used for templates specified by '--pdb-hit-file'. ",
+ )
+
+ pred_group = parser.add_argument_group("Prediction arguments", "")
+ pred_group.add_argument(
+ "--num-recycle",
+ help="Number of prediction recycles. "
+ "Increasing recycles can improve the prediction quality but slows down the prediction.",
+ type=int,
+ default=None,
+ )
+ pred_group.add_argument(
+ "--recycle-early-stop-tolerance",
+ help="Specify convergence criteria. "
+ "Run recycles until the distance between recycles is within the given tolerance value.",
+ type=float,
+ default=None,
+ )
+ pred_group.add_argument(
+ "--num-ensemble",
+ help="Number of ensembles. "
+ "The trunk of the network is run multiple times with different random choices for the MSA cluster centers. "
+ "This can result in a better prediction at the cost of longer runtime. ",
+ type=int,
+ default=1,
+ )
+ pred_group.add_argument(
+ "--num-seeds",
+ help="Number of seeds to try. Will iterate from range(random_seed, random_seed+num_seeds). "
+ "This can result in a better/different prediction at the cost of longer runtime. ",
+ type=int,
+ default=1,
+ )
+ pred_group.add_argument(
+ "--random-seed",
+ help="Changing the seed for the random number generator can result in better/different structure predictions.",
+ type=int,
+ default=0,
+ )
+ pred_group.add_argument(
+ "--num-models",
+ help="Number of models to use for structure prediction. "
+ "Reducing the number of models speeds up the prediction but results in lower quality.",
+ type=int,
+ default=5,
+ choices=[1, 2, 3, 4, 5],
+ )
+ pred_group.add_argument(
+ "--model-type",
+ help="Predict structure/complex using the given model. "
+ 'Auto will pick "alphafold2_ptm" for structure predictions and "alphafold2_multimer_v3" for complexes. '
+ "Older versions of the AF2 models are generally worse, however they can sometimes result in better predictions. "
+ "If the model is not already downloaded, it will be automatically downloaded. ",
+ type=str,
+ default="auto",
+ choices=[
+ "auto",
+ "alphafold2",
+ "alphafold2_ptm",
+ "alphafold2_multimer_v1",
+ "alphafold2_multimer_v2",
+ "alphafold2_multimer_v3",
+ "deepfold_v1",
+ ],
+ )
+ pred_group.add_argument("--model-order", default="1,2,3,4,5", type=str)
+ pred_group.add_argument(
+ "--initial-guess",
+ nargs="?",
+ const=True,
+ help="Specify a starting model for the prediction. If the main input file is a PDB format, "
+ "it will be used as the initial guess. Otherwise, you can provide an input file with this flag, "
+ "which will override the main input."
+ )
+ pred_group.add_argument(
+ "--use-dropout",
+ default=False,
+ action="store_true",
+ help="Activate dropouts during inference to sample from uncertainty of the models. "
+ "This can result in different predictions and can be (carefully!) used for conformations sampling.",
+ )
+ pred_group.add_argument(
+ "--max-seq",
+ help="Number of sequence clusters to use. "
+ "This can result in different predictions and can be (carefully!) used for conformations sampling.",
+ type=int,
+ default=None,
+ )
+ pred_group.add_argument(
+ "--max-extra-seq",
+ help="Number of extra sequences to use. "
+ "This can result in different predictions and can be (carefully!) used for conformations sampling.",
+ type=int,
+ default=None,
+ )
+ pred_group.add_argument(
+ "--max-msa",
+ help="Defines: `max-seq:max-extra-seq` number of sequences to use in one go. "
+ '"--max-seq" and "--max-extra-seq" are ignored if this parameter is set.',
+ type=str,
+ default=None,
+ )
+ pred_group.add_argument(
+ "--disable-cluster-profile",
+ default=False,
+ action="store_true",
+ help="Experimental: For multimer models, disable cluster profiles.",
+ )
+ pred_group.add_argument(
+ "--calc-extra-ptm",
+ default=False,
+ action="store_true",
+ help="Experimental: calculate pairwise metrics (ipTM and actifpTM), and also chain-wise pTM",
+ )
+ pred_group.add_argument(
+ "--no-use-probs-extra",
+ default=False,
+ action="store_true",
+ help="Experimental: instead of contact probabilities form use binary contacts for extra metrics calculation",
+ )
+ pred_group.add_argument("--data", help="Path to AlphaFold2 weights directory.")
+
+ relax_group = parser.add_argument_group("Relaxation arguments", "")
+ relax_group.add_argument(
+ "--amber",
+ default=False,
+ action="store_true",
+ help="Enable OpenMM/Amber for structure relaxation. "
+ "Can improve the quality of side-chains at a cost of longer runtime. "
+ )
+ relax_group.add_argument(
+ "--num-relax",
+ help="Specify how many of the top ranked structures to relax using OpenMM/Amber. "
+ "Typically, relaxing the top-ranked prediction is enough and speeds up the runtime. ",
+ type=int,
+ default=0,
+ )
+ relax_group.add_argument(
+ "--relax-max-iterations",
+ type=int,
+ default=2000,
+ help="Maximum number of iterations for the relaxation process. "
+ "AlphaFold2 sets this to unlimited (0), however, we found that this can lead to very long relaxation times for some inputs.",
+ )
+ relax_group.add_argument(
+ "--relax-tolerance",
+ type=float,
+ default=2.39,
+ help="Tolerance threshold for relaxation convergence.",
+ )
+ relax_group.add_argument(
+ "--relax-stiffness",
+ type=float,
+ default=10.0,
+ help="Stiffness parameter for relaxation.",
+ )
+ relax_group.add_argument(
+ "--relax-max-outer-iterations",
+ type=int,
+ default=3,
+ help="Maximum number of outer iterations for the relaxation process.",
+ )
+ relax_group.add_argument(
+ "--use-gpu-relax",
+ default=False,
+ action="store_true",
+ help="Run OpenMM/Amber on GPU instead of CPU. "
+ "This can significantly speed up the relaxation runtime, however, might lead to compatibility issues with CUDA. "
+ "Unsupported on AMD/ROCM and Apple Silicon.",
+ )
+
+ output_group = parser.add_argument_group("Output arguments", "")
+ output_group.add_argument(
+ "--rank",
+ help='Choose metric to rank the "--num-models" predicted models.',
+ type=str,
+ default="auto",
+ choices=["auto", "plddt", "ptm", "iptm", "multimer"],
+ )
+ output_group.add_argument(
+ "--stop-at-score",
+ help="Compute models until pLDDT (single chain) or pTM-score (multimer) > threshold is reached. "
+ "This speeds up prediction by running less models for easier queries.",
+ type=float,
+ default=100,
+ )
+ output_group.add_argument(
+ "--jobname-prefix",
+ help="If set, the jobname will be prefixed with the given string and a running number, instead of the input headers/accession.",
+ type=str,
+ default=None,
+ )
+ output_group.add_argument(
+ "--save-all",
+ default=False,
+ action="store_true",
+ help="Save all raw outputs from model to a pickle file. "
+ "Useful for downstream use in other models."
+ )
+ output_group.add_argument(
+ "--save-recycles",
+ default=False,
+ action="store_true",
+ help="Save all intermediate predictions at each recycle iteration.",
+ )
+ output_group.add_argument(
+ "--save-single-representations",
+ default=False,
+ action="store_true",
+ help="Save the single representation embeddings of all models.",
+ )
+ output_group.add_argument(
+ "--save-pair-representations",
+ default=False,
+ action="store_true",
+ help="Save the pair representation embeddings of all models.",
+ )
+ def comma_separated_list(arg_string):
+ return [item.strip() for item in arg_string.split(',') if item.strip() in ['msa', 'plots', 'pae_json']]
+ output_group.add_argument(
+ "--skip-output",
+ help="Comma-separated list of output types to skip: msa, plots, pae_json.",
+ type=comma_separated_list,
+ default="",
+ )
+ output_group.add_argument(
+ "--overwrite-existing-results",
+ default=False,
+ action="store_true",
+ help="Do not recompute results, if a query has already been predicted.",
+ )
+ output_group.add_argument(
+ "--zip",
+ default=False,
+ action="store_true",
+ help="Zip all results into one "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G4yBrceuFbf3"
+ },
+ "source": [
+ "#AlphaFold"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "axC4Ym4XT1wA"
+ },
+ "source": [
+ "#################\n",
+ "# WARNING \n",
+ "#################\n",
+ "# - This notebook is intended as a \"quick\" demo, it disables many aspects of the full alphafold2 pipeline \n",
+ "# (input MSA/templates, amber MD refinement, and number of models). For best results, we recommend using the\n",
+ "# full pipeline: https://github.com/deepmind/alphafold\n",
+ "# - That being said, it was found that input templates and amber-relax did not help much.\n",
+ "# The key input features are the MSA (Multiple Sequence Alignment) of related proteins. Where you see a \n",
+ "# significant drop in predicted accuracy when MSA < 30, but only minor improvements > 100. \n",
+ "# - This notebook does NOT include the alphafold2 MSA generation pipeline, and is designed to work with a\n",
+ "# single sequence, custom MSA input (that you can upload) or MMseqs2 webserver.\n",
+ "# - Single sequence mode is particularly useful for denovo designed proteins (where there are no sequence\n",
+ "# homologs by definition). For natural proteins, an MSA input will make a huge difference.\n",
+ "\n",
+ "#################\n",
+ "# EXTRA\n",
+ "#################\n",
+ "# For other related notebooks see: https://github.com/sokrypton/ColabFold"
+ ],
+ "execution_count": 1,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# install/import alphafold (and required libs)\n",
+ "import os, sys\n",
+ "if not os.path.isdir(\"/content/alphafold\"):\n",
+ " %shell git clone -q https://github.com/deepmind/alphafold.git; cd alphafold; git checkout -q 1d43aaff941c84dc56311076b58795797e49107b\n",
+ " %shell mkdir --parents params; curl -fsSL https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar | tar x -C params\n",
+ " %shell pip -q install biopython dm-haiku==0.0.5 ml-collections py3Dmol\n",
+ "if '/content/alphafold' not in sys.path:\n",
+ " sys.path.append('/content/alphafold')\n",
+ "\n",
+ "import numpy as np\n",
+ "import py3Dmol\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "from alphafold.common import protein\n",
+ "from alphafold.data import pipeline\n",
+ "from alphafold.data import templates\n",
+ "from alphafold.model import data\n",
+ "from alphafold.model import config\n",
+ "from alphafold.model import model"
+ ],
+ "metadata": {
+ "id": "QxwvsT9nSjpH"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "_1WwozC4ZfPL"
+ },
+ "source": [
+ "# setup which model params to use\n",
+ "# note: for this demo, we only use model 1, for all five models uncomments the others!\n",
+ "model_runners = {}\n",
+ "models = [\"model_1\"] #,\"model_2\",\"model_3\",\"model_4\",\"model_5\"]\n",
+ "for model_name in models:\n",
+ " model_config = config.model_config(model_name)\n",
+ " model_config.data.eval.num_ensemble = 1\n",
+ " model_params = data.get_model_haiku_params(model_name=model_name, data_dir=\".\")\n",
+ " model_runner = model.RunModel(model_config, model_params)\n",
+ " model_runners[model_name] = model_runner"
+ ],
+ "execution_count": 3,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "fVvEiovadj7z"
+ },
+ "source": [
+ "def mk_mock_template(query_sequence):\n",
+ " '''create blank template'''\n",
+ " ln = len(query_sequence)\n",
+ " output_templates_sequence = \"-\"*ln\n",
+ " templates_all_atom_positions = np.zeros((ln, templates.residue_constants.atom_type_num, 3))\n",
+ " templates_all_atom_masks = np.zeros((ln, templates.residue_constants.atom_type_num))\n",
+ " templates_aatype = templates.residue_constants.sequence_to_onehot(output_templates_sequence,templates.residue_constants.HHBLITS_AA_TO_ID)\n",
+ " template_features = {'template_all_atom_positions': templates_all_atom_positions[None],\n",
+ " 'template_all_atom_masks': templates_all_atom_masks[None],\n",
+ " 'template_aatype': np.array(templates_aatype)[None],\n",
+ " 'template_domain_names': [f'none'.encode()]}\n",
+ " return template_features"
+ ],
+ "execution_count": 4,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "UpsmhexoZgPQ"
+ },
+ "source": [
+ "def predict_structure(prefix, feature_dict, model_runners, random_seed=0): \n",
+ " \"\"\"Predicts structure using AlphaFold for the given sequence.\"\"\"\n",
+ "\n",
+ " # Run the models.\n",
+ " plddts = {}\n",
+ " for model_name, model_runner in model_runners.items():\n",
+ " processed_feature_dict = model_runner.process_features(feature_dict, random_seed=random_seed)\n",
+ " prediction_result = model_runner.predict(processed_feature_dict)\n",
+ " unrelaxed_protein = protein.from_prediction(processed_feature_dict,prediction_result)\n",
+ " unrelaxed_pdb_path = f'{prefix}_unrelaxed_{model_name}.pdb'\n",
+ " plddts[model_name] = prediction_result['plddt']\n",
+ "\n",
+ " print(f\"{model_name} {plddts[model_name].mean()}\")\n",
+ "\n",
+ " with open(unrelaxed_pdb_path, 'w') as f:\n",
+ " f.write(protein.to_pdb(unrelaxed_protein))\n",
+ " return plddts"
+ ],
+ "execution_count": 5,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oYfcIv16epCD"
+ },
+ "source": [
+ "# Single sequence input (no MSA)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "KNFnG3e9ZhOa"
+ },
+ "source": [
+ "# Change this line to sequence you want to predict\n",
+ "query_sequence = \"GWSTELEKHREELKEFLKKEGITNVEIRIDNGRLEVRVEGGTERLKRFLEELRQKLEKKGYTVDIKIE\""
+ ],
+ "execution_count": 6,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "X9XuqtNdZjG5",
+ "outputId": "e8f96072-6613-4695-d7d9-94bcc85fbe95"
+ },
+ "source": [
+ "%%time\n",
+ "feature_dict = {\n",
+ " **pipeline.make_sequence_features(sequence=query_sequence,\n",
+ " description=\"none\",\n",
+ " num_res=len(query_sequence)),\n",
+ " **pipeline.make_msa_features(msas=[[query_sequence]],\n",
+ " deletion_matrices=[[[0]*len(query_sequence)]]),\n",
+ " **mk_mock_template(query_sequence)\n",
+ "}\n",
+ "plddts = predict_structure(\"test\",feature_dict,model_runners)"
+ ],
+ "execution_count": 7,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "model_1 83.72061105785679\n",
+ "CPU times: user 6min 43s, sys: 10.4 s, total: 6min 54s\n",
+ "Wall time: 4min 44s\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "aH4RGsKt1huZ",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 387
+ },
+ "outputId": "7136de78-fa5c-496f-dbce-086ed74a12bf"
+ },
+ "source": [
+ "# confidence per position\n",
+ "plt.figure(dpi=100)\n",
+ "for model,value in plddts.items():\n",
+ " plt.plot(value,label=model)\n",
+ "plt.legend()\n",
+ "plt.ylim(0,100)\n",
+ "plt.ylabel(\"predicted LDDT\")\n",
+ "plt.xlabel(\"positions\")\n",
+ "plt.show()"
+ ],
+ "execution_count": 8,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G4yBrceuFbf3"
+ },
+ "source": [
+ "#AlphaFold"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "8rAMCSBzLLsG"
+ },
+ "source": [
+ "#################\n",
+ "# WARNING \n",
+ "#################\n",
+ "# - This notebook is intended as a \"quick\" demo, it disables many aspects of the full alphafold2 pipeline \n",
+ "# (input MSA/templates and number of models). For best results, we recommend using the full pipeline: \n",
+ "# https://github.com/deepmind/alphafold\n",
+ "# - That being said, it was found that input templates and amber-relax did not help much.\n",
+ "# The key input features are the MSA (Multiple Sequence Alignment) of related proteins. Where you see a \n",
+ "# significant drop in predicted accuracy when MSA < 30, but only minor improvements > 100. \n",
+ "# - This notebook does NOT include the alphafold2 MSA generation pipeline, and is designed to work with a\n",
+ "# single sequence, custom MSA input (that you can upload) or MMseqs2 webserver.\n",
+ "# - Single sequence mode is particularly useful for denovo designed proteins (where there are no sequence\n",
+ "# homologs by definition). For natural proteins, an MSA input will make a huge difference.\n",
+ "\n",
+ "#################\n",
+ "# EXTRA\n",
+ "#################\n",
+ "# For other related notebooks see: https://github.com/sokrypton/ColabFold"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "8v06TAo9ZaGH",
+ "outputId": "8976aecc-a44c-4220-9c2a-e5fbe9f207b8"
+ },
+ "source": [
+ "%%bash\n",
+ "# download model\n",
+ "git clone https://github.com/deepmind/alphafold.git\n",
+ "mv alphafold alphafold_\n",
+ "mv alphafold_/alphafold .\n",
+ "# remove \"END\" from PDBs, otherwise biopython complains\n",
+ "sed -i \"s/pdb_lines.append('END')//\" alphafold/common/protein.py\n",
+ "sed -i \"s/pdb_lines.append('ENDMDL')//\" alphafold/common/protein.py"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "Cloning into 'alphafold'...\n"
+ ],
+ "name": "stderr"
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "S4JiVuyyFCpx"
+ },
+ "source": [
+ "%%bash\n",
+ "# download model params (~1 min)\n",
+ "wget -qnc https://storage.googleapis.com/alphafold/alphafold_params_2021-07-14.tar\n",
+ "mkdir params\n",
+ "tar -xf alphafold_params_2021-07-14.tar -C params/\n",
+ "rm alphafold_params_2021-07-14.tar"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Q5Zk_XqEZcCe"
+ },
+ "source": [
+ "%%bash\n",
+ "pip -q install biopython\n",
+ "pip -q install dm-haiku\n",
+ "pip -q install ml-collections\n",
+ "\n",
+ "# install py3Dmol for visualization\n",
+ "pip -q install py3Dmol"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "_xmNETYP_z_i",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "outputId": "56472174-15d9-4171-cec2-0011e14bef23"
+ },
+ "source": [
+ "%%bash\n",
+ "# install openmm for refinement\n",
+ "wget -qnc https://git.scicore.unibas.ch/schwede/openstructure/-/raw/7102c63615b64735c4941278d92b554ec94415f8/modules/mol/alg/src/stereo_chemical_props.txt\n",
+ "mv stereo_chemical_props.txt alphafold/common/\n",
+ "wget -qnc https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh \n",
+ "bash Miniconda3-latest-Linux-x86_64.sh -bfp /usr/local 2>&1 1>/dev/null\n",
+ "conda install -y -q -c conda-forge openmm=7.5.1 python=3.7 pdbfixer 2>&1 1>/dev/null\n",
+ "cd /usr/local/lib/python3.7/site-packages\n",
+ "patch -p0 < /content/alphafold_/docker/openmm.patch"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "\r 0%| | 0/36 [00:00"
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 496
+ },
+ "id": "SbuQyLnvZkBb",
+ "outputId": "e16e19f3-ca44-4cc3-9a82-179180245359"
+ },
+ "source": [
+ " p = py3Dmol.view(js='https://3dmol.org/build/3Dmol.js')\n",
+ " p.addModel(open(\"test_relaxed_model_1.pdb\",'r').read(),'pdb')\n",
+ " p.setStyle({'cartoon': {'color':'spectrum'}})\n",
+ " p.zoomTo()\n",
+ " p.show()"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/3dmoljs_load.v0": "You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n jupyter labextension install jupyterlab_3dmol
You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension:
\n",
+ " jupyter labextension install jupyterlab_3dmol