Update parquet files

.gitattributes

@@ -0,0 +1 @@
+default/pdbbind_complexes-train.parquet filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,45 +0,0 @@
----
-tags:
-- molecules
-- chemistry
-- SMILES
----
-
-## How to use the data sets
-
-This dataset contains more than 16,000 unique pairs of protein sequences and ligand SMILES, and the coordinates
-of their complexes.
-
-SMILES are assumed to be tokenized by the regex from P. Schwaller
-
-Every (x,y,z) ligand coordinate maps onto a SMILES token, and is *nan* if the token does not represent an atom
-
-Every receptor coordinate maps onto the Calpha coordinate of that residue.
-
-The dataset can be used to fine-tune a language model, all data comes from PDBind-cn.
-
-### Use the already preprocessed data
-
-Load a test/train split using
-
-```
-from datasets import load_dataset
-train = load_dataset("jglaser/pdbbind_complexes",split='train[:90%]')
-validation = load_dataset("jglaser/pdbbind_complexes",split='train[90%:]')
-```
-
-### Pre-process yourself
-
-To manually perform the preprocessing, download the data sets from P.DBBind-cn
-
-Register for an account at <https://www.pdbbind.org.cn/>, confirm the validation
-email, then login and download 
-
-- the Index files (1)
-- the general protein-ligand complexes (2)
-- the refined protein-ligand complexes (3)
-
-Extract those files in `pdbbind/data`
-
-Run the script `pdbbind.py` in a compute job on an MPI-enabled cluster
-(e.g., `mpirun -n 64 pdbbind.py`).

data/pdbbind.parquet → default/pdbbind_complexes-train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aef30f419b99fb77199c8b68e260febf303b4a50a7affcaa2de7bd538e6d8673
-size 711749176
+oid sha256:a02d99f9fb9a81c9465ea40e1232bf857725707a688034ca3388f67259ef27b8
+size 382706029

pdbbind.ipynb

@@ -1,517 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "834aeced-c3c5-42a0-bad1-41e009dd86ee",
-   "metadata": {},
-   "source": [
-    "### Preprocessing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "86476f6e-802a-463b-a1b0-2ae228bb92af",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "9b2be11c-f4bb-4107-af49-abd78052afcf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df = pd.read_table('data/pdbbind/index/INDEX_general_PL_data.2020',skiprows=4,sep=r'\\s+',usecols=[0,4]).drop(0)\n",
-    "df = df.rename(columns={'#': 'name','release': 'affinity'})\n",
-    "df_refined = pd.read_table('data/pdbbind/index/INDEX_refined_data.2020',skiprows=4,sep=r'\\s+',usecols=[0,4]).drop(0)\n",
-    "df_refined = df_refined.rename(columns={'#': 'name','release': 'affinity'})\n",
-    "df = pd.concat([df,df_refined])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "68983ab8-bf11-4ed6-ba06-f962dbdc077e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "quantities = ['ki','kd','ka','k1/2','kb','ic50','ec50']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "3acbca3c-9c0b-43a1-a45e-331bf153bcfa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pint import UnitRegistry\n",
-    "ureg = UnitRegistry()\n",
-    "\n",
-    "def to_uM(affinity):\n",
-    "    val = ureg(affinity)\n",
-    "    try:\n",
-    "        return val.m_as(ureg.uM)\n",
-    "    except Exception:\n",
-    "        pass\n",
-    "    \n",
-    "    try:\n",
-    "        return 1/val.m_as(1/ureg.uM)\n",
-    "    except Exception:\n",
-    "        pass"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "58e5748b-2cea-43ff-ab51-85a5021bd50b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df['affinity_uM'] = df['affinity'].str.split('[=\\~><]').str[1].apply(to_uM)\n",
-    "df['affinity_quantity'] = df['affinity'].str.split('[=\\~><]').str[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "d92f0004-68c1-4487-94b9-56b4fd598de4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<AxesSubplot:>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "df['affinity_quantity'].hist()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "aa358835-55f3-4551-9217-e76a15de4fe8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df_filter = df[df['affinity_quantity'].str.lower().isin(quantities)]\n",
-    "df_filter = df_filter.dropna()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "802cb9bc-2563-4d7f-9a76-3be2d9263a36",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cutoffs = [5,8,11,15]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "d8e71a8c-11a3-41f0-ab61-3ddc57e10961",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dfs_complex = {c: pd.read_parquet('data/pdbbind_complex_{}.parquet'.format(c)) for c in cutoffs}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "ed3fe035-6035-4d39-b072-d12dc0a95857",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import dask.array as da\n",
-    "import dask.dataframe as dd\n",
-    "from dask.bag import from_delayed\n",
-    "from dask import delayed\n",
-    "import pyarrow as pa\n",
-    "import pyarrow.parquet as pq"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "cd26125b-e68b-4fa3-846e-2b6e7f635fe0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(2046, 510)\n"
-     ]
-    }
-   ],
-   "source": [
-    "contacts_dask = [da.from_npy_stack('data/pdbbind_contacts_{}'.format(c)) for c in cutoffs]\n",
-    "shape = contacts_dask[0][0].shape\n",
-    "print(shape)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "9c7c9849-2345-4baf-89e7-d412f52353b6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table>\n",
-       "<tr>\n",
-       "<td>\n",
-       "<table>\n",
-       "  <thead>\n",
-       "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr><th> Bytes </th><td> 2.72 GiB </td> <td> 2.72 GiB </td></tr>\n",
-       "    <tr><th> Shape </th><td> (700, 2046, 510) </td> <td> (700, 2046, 510) </td></tr>\n",
-       "    <tr><th> Count </th><td> 25 Tasks </td><td> 1 Chunks </td></tr>\n",
-       "    <tr><th> Type </th><td> float32 </td><td> numpy.ndarray </td></tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</td>\n",
-       "<td>\n",
-       "<svg width=\"128\" height=\"195\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"10\" y1=\"0\" x2=\"35\" y2=\"25\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"10\" y1=\"120\" x2=\"35\" y2=\"145\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"10\" y1=\"0\" x2=\"10\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"35\" y1=\"25\" x2=\"35\" y2=\"145\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"10.0,0.0 35.86269549127143,25.86269549127143 35.86269549127143,145.86269549127144 10.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"10\" y1=\"0\" x2=\"52\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"35\" y1=\"25\" x2=\"78\" y2=\"25\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"10\" y1=\"0\" x2=\"35\" y2=\"25\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"52\" y1=\"0\" x2=\"78\" y2=\"25\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"10.0,0.0 52.88780092952726,0.0 78.7504964207987,25.86269549127143 35.86269549127143,25.86269549127143\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"35\" y1=\"25\" x2=\"78\" y2=\"25\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"35\" y1=\"145\" x2=\"78\" y2=\"145\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"35\" y1=\"25\" x2=\"35\" y2=\"145\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"78\" y1=\"25\" x2=\"78\" y2=\"145\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"35.86269549127143,25.86269549127143 78.7504964207987,25.86269549127143 78.7504964207987,145.86269549127144 35.86269549127143,145.86269549127144\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"57.306596\" y=\"165.862695\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >510</text>\n",
-       "  <text x=\"98.750496\" y=\"85.862695\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(-90,98.750496,85.862695)\">2046</text>\n",
-       "  <text x=\"12.931348\" y=\"152.931348\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(45,12.931348,152.931348)\">700</text>\n",
-       "</svg>\n",
-       "</td>\n",
-       "</tr>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "dask.array<blocks, shape=(700, 2046, 510), dtype=float32, chunksize=(700, 2046, 510), chunktype=numpy.ndarray>"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "contacts_dask[0].blocks[1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "0bd8e9b9-9713-4572-bd7f-dc47da9fce91",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[16232, 16228, 16226, 16223]"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "[len(c) for c in contacts_dask]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "87493934-3839-476a-a975-7da057c320da",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "16232"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "contacts_dask[0].shape[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "42e95d84-ef27-4417-9479-8b356462b8c3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "all_partitions = []\n",
-    "for c, cutoff in zip(contacts_dask,cutoffs):\n",
-    "    def chunk_to_sparse(rcut, chunk, idx_chunk):\n",
-    "        res = dfs_complex[rcut].iloc[idx_chunk][['name']].copy()\n",
-    "        # pad to account for [CLS] and [SEP]\n",
-    "        res['contacts_{}A'.format(rcut)] = [np.where(np.pad(a,pad_width=(1,1)).flatten())[0] for a in chunk]\n",
-    "        return res\n",
-    "\n",
-    "    partitions = [delayed(chunk_to_sparse)(cutoff,b,k)\n",
-    "                  for b,k in zip(c.blocks, da.arange(c.shape[0],chunks=c.chunks[0:1]).blocks)\n",
-    "                 ]\n",
-    "    all_partitions.append(partitions)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "5520a925-693f-43f0-9e76-df2e128f272e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>name</th>\n",
-       "      <th>contacts_5A</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>10gs</td>\n",
-       "      <td>[3083, 3084, 3086, 3087, 3088, 3089, 3094, 309...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>184l</td>\n",
-       "      <td>[39945, 39946, 39947, 39948, 43010, 43012, 430...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>186l</td>\n",
-       "      <td>[39943, 39944, 39945, 43010, 43011, 43012, 430...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>187l</td>\n",
-       "      <td>[39937, 39938, 39947, 43009, 43010, 43012, 430...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>188l</td>\n",
-       "      <td>[39937, 39938, 39940, 39941, 43009, 43010, 430...</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "   name                                        contacts_5A\n",
-       "0  10gs  [3083, 3084, 3086, 3087, 3088, 3089, 3094, 309...\n",
-       "1  184l  [39945, 39946, 39947, 39948, 43010, 43012, 430...\n",
-       "2  186l  [39943, 39944, 39945, 43010, 43011, 43012, 430...\n",
-       "3  187l  [39937, 39938, 39947, 43009, 43010, 43012, 430...\n",
-       "4  188l  [39937, 39938, 39940, 39941, 43009, 43010, 430..."
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_partitions[0][0].compute().head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "4982c3b1-5ce9-4f17-9834-a02c4e136bc2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ddfs = [dd.from_delayed(p) for p in all_partitions]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "f6cdee43-33c6-445c-8619-ace20f90638c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ddf_all = None\n",
-    "for d in ddfs:\n",
-    "    if ddf_all is not None:\n",
-    "        ddf_all = ddf_all.merge(d, on='name')\n",
-    "    else:\n",
-    "        ddf_all = d\n",
-    "ddf_all = ddf_all.merge(df_filter,on='name')\n",
-    "ddf_all = ddf_all.merge(list(dfs_complex.values())[0],on='name')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "8f49f871-76f6-4fb2-b2db-c0794d4c07bf",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 8min 53s, sys: 11min 31s, total: 20min 24s\n",
-      "Wall time: 3min 29s\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%time\n",
-    "df_all_contacts = ddf_all.compute()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "45e4b4fa-6338-4abe-bd6e-8aea46e2a09c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df_all_contacts['neg_log10_affinity_M'] = 6-np.log10(df_all_contacts['affinity_uM'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "7c3db301-6565-4053-bbd4-139bb41dd1c4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(array([6.34387834]), array([3.57815698]))"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from sklearn.preprocessing import StandardScaler\n",
-    "scaler = StandardScaler()\n",
-    "df_all_contacts['affinity'] = scaler.fit_transform(df_all_contacts['neg_log10_affinity_M'].values.reshape(-1,1))\n",
-    "scaler.mean_, scaler.var_"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "c9d674bb-d6a2-4810-aa2b-e3bc3b4bbc98",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# save to parquet\n",
-    "df_all_contacts.drop(columns=['name','affinity_quantity']).astype({'affinity': 'float32','neg_log10_affinity_M': 'float32'}).to_parquet('data/pdbbind_with_contacts.parquet',index=False)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pdbbind.py

@@ -1,177 +0,0 @@
-from mpi4py import MPI
-from mpi4py.futures import MPICommExecutor
-
-import warnings
-from Bio.PDB import PDBParser, PPBuilder, CaPPBuilder
-from Bio.PDB.NeighborSearch import NeighborSearch
-from Bio.PDB.Selection import unfold_entities
-
-import numpy as np
-import dask.array as da
-
-from rdkit import Chem
-
-from spyrmsd import molecule
-from spyrmsd import graph
-import networkx as nx
-
-import os
-import re
-import sys
-
-# all punctuation
-punctuation_regex  = r"""(\(|\)|\.|=|#|-|\+|\\|\/|:|~|@|\?|>>?|\*|\$|\%[0-9]{2}|[0-9])"""
-
-# tokenization regex (Schwaller)
-molecule_regex = r"""(\[[^\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\(|\)|\.|=|#|-|\+|\\|\/|:|~|@|\?|>>?|\*|\$|\%[0-9]{2}|[0-9])"""
-
-max_seq = 2046 # = 2048 - 2 (accounting for [CLS] and [SEP])
-max_smiles = 510 # = 512 - 2
-chunk_size = '1G'
-
-def rot_from_two_vecs(e0_unnormalized, e1_unnormalized):
-    """Create rotation matrices from unnormalized vectors for the x and y-axes.
-    This creates a rotation matrix from two vectors using Gram-Schmidt
-    orthogonalization.
-    Args:
-    e0_unnormalized: vectors lying along x-axis of resulting rotation
-    e1_unnormalized: vectors lying in xy-plane of resulting rotation
-    Returns:
-    Rotations resulting from Gram-Schmidt procedure.
-    """
-    # Normalize the unit vector for the x-axis, e0.
-    e0 = e0_unnormalized / np.linalg.norm(e0_unnormalized)
-
-    # make e1 perpendicular to e0.
-    c = np.dot(e1_unnormalized, e0)
-    e1 = e1_unnormalized - c * e0
-    e1 = e1 / np.linalg.norm(e1)
-
-    # Compute e2 as cross product of e0 and e1.
-    e2 = np.cross(e0, e1)
-
-    # local to space frame
-    return np.stack([e0,e1,e2]).T
-
-def get_local_frames(mol):
-    # get the two nearest neighbors of every atom on the molecular graph
-    # ties are broken using canonical ordering
-    g = molecule.Molecule.from_rdkit(mol).to_graph()
-
-    R = []
-    for node in g:
-        length = nx.single_source_shortest_path_length(g, node)
-
-        neighbor_a = [n for n,l in length.items() if l==1][0]
-
-        try:
-            neighbor_b = [n for n,l in length.items() if l==1][1]
-        except:
-            # get next nearest neighbor
-            neighbor_b = [n for n,l in length.items() if l==2][0]
-
-        xyz = np.array(mol.GetConformer().GetAtomPosition(node))
-        xyz_a = np.array(mol.GetConformer().GetAtomPosition(neighbor_a))
-        xyz_b = np.array(mol.GetConformer().GetAtomPosition(neighbor_b))
-
-        R.append(rot_from_two_vecs(xyz_a-xyz, xyz_b-xyz))
-
-    return R
-
-def parse_complex(fn):
-    try:
-        name = os.path.basename(fn)
-
-        # parse protein sequence and coordinates
-        parser = PDBParser()
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            structure = parser.get_structure('protein',fn+'/'+name+'_protein.pdb')
-
-        res_frames = []
-
-        # extract sequence, Calpha positions and local coordinate frames using the AF2 convention
-        ppb = CaPPBuilder()
-        seq = []
-        xyz_receptor = []
-        R_receptor = []
-        for pp in ppb.build_peptides(structure):
-            seq.append(str(pp.get_sequence()))
-            xyz_receptor += [tuple(a.get_vector()) for a in pp.get_ca_list()]
-
-            for res in pp:
-                N = np.array(tuple(res['N'].get_vector()))
-                C = np.array(tuple(res['C'].get_vector()))
-                CA = np.array(tuple(res['CA'].get_vector()))
-
-                R_receptor.append(rot_from_two_vecs(N-CA,C-CA).flatten().tolist())
-
-        seq = ''.join(seq)
-
-        # parse ligand, convert to SMILES and map atoms
-        suppl = Chem.SDMolSupplier(fn+'/'+name+'_ligand.sdf')
-        mol = next(suppl)
-
-        # bring molecule atoms in canonical order (to determine local frames uniquely)
-        m_neworder = tuple(zip(*sorted([(j, i) for i, j in enumerate(Chem.CanonicalRankAtoms(mol))])))[1]
-        mol = Chem.RenumberAtoms(mol, m_neworder)
-
-        # position of atoms in SMILES (not counting punctuation)
-        smi = Chem.MolToSmiles(mol)
-        atom_order = [int(s) for s in list(filter(None,re.sub(r'[\[\]]','',mol.GetProp("_smilesAtomOutputOrder")).split(',')))]
-
-        # tokenize the SMILES
-        tokens = list(filter(None, re.split(molecule_regex, smi)))
-
-        # remove punctuation
-        masked_tokens = [re.sub(punctuation_regex,'',s) for s in tokens]
-
-        k = 0
-        token_pos = []
-        token_rot = []
-
-        frames = get_local_frames(mol)
-
-        for i,token in enumerate(masked_tokens):
-            if token != '':
-                token_pos.append(tuple(mol.GetConformer().GetAtomPosition(atom_order[k])))
-                token_rot.append(frames[atom_order[k]].flatten().tolist())
-                k += 1
-            else:
-                token_pos.append((np.nan, np.nan, np.nan))
-                token_rot.append(np.eye(3).flatten().tolist())
-
-        return name, seq, smi, xyz_receptor, token_pos, token_rot, R_receptor
-
-    except Exception as e:
-        print(e)
-        return None
-
-
-if __name__ == '__main__':
-    import glob
-
-    filenames = glob.glob('data/pdbbind/v2020-other-PL/*')
-    filenames.extend(glob.glob('data/pdbbind/refined-set/*'))
-    filenames = sorted(filenames)
-    comm = MPI.COMM_WORLD
-    with MPICommExecutor(comm, root=0) as executor:
-        if executor is not None:
-            result = executor.map(parse_complex, filenames, chunksize=32)
-            result = list(result)
-            names = [r[0] for r in result if r is not None]
-            seqs = [r[1] for r in result if r is not None]
-            all_smiles = [r[2] for r in result if r is not None]
-            all_xyz_receptor = [r[3] for r in result if r is not None]
-            all_xyz_ligand = [r[4] for r in result if r is not None]
-            all_rot_ligand = [r[5] for r in result if r is not None]
-            all_rot_receptor = [r[6] for r in result if r is not None]
-
-            import pandas as pd
-            df = pd.DataFrame({'name': names, 'seq': seqs,
-                               'smiles': all_smiles,
-                               'receptor_xyz': all_xyz_receptor,
-                               'ligand_xyz': all_xyz_ligand,
-                               'ligand_rot': all_rot_ligand,
-                               'receptor_rot': all_rot_receptor})
-            df.to_parquet('data/pdbbind.parquet',index=False)

pdbbind.slurm

@@ -1,9 +0,0 @@
-#!/bin/bash
-#SBATCH -J preprocess_pdbbind
-#SBATCH -p batch
-#SBATCH -A STF006
-#SBATCH -t 3:00:00
-#SBATCH -N 4
-#SBATCH --ntasks-per-node=8
-
-srun python pdbbind.py

pdbbind_complexes.py

@@ -1,131 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""TODO: A dataset of protein sequences, ligand SMILES, and complex coordinates."""
-
-import huggingface_hub
-import os
-import pyarrow.parquet as pq
-import datasets
-
-
-# TODO: Add BibTeX citation
-# Find for instance the citation on arxiv or on the dataset repo/website
-_CITATION = """\
-@InProceedings{huggingface:dataset,
-title = {jglaser/pdbbind_complexes},
-author={Jens Glaser, ORNL
-},
-year={2022}
-}
-"""
-
-# TODO: Add description of the dataset here
-# You can copy an official description
-_DESCRIPTION = """\
-A dataset to fine-tune language models on protein-ligand binding affinity and contact prediction.
-"""
-
-# TODO: Add a link to an official homepage for the dataset here
-_HOMEPAGE = ""
-
-# TODO: Add the licence for the dataset here if you can find it
-_LICENSE = "BSD two-clause"
-
-# TODO: Add link to the official dataset URLs here
-# The HuggingFace dataset library don't host the datasets but only point to the original files
-# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
-_URL = "https://huggingface.co/datasets/jglaser/pdbbind_complexes/resolve/main/"
-_data_dir = "data/"
-_file_names = {'default': _data_dir+'pdbbind.parquet'}
-
-_URLs = {name: _URL+_file_names[name] for name in _file_names}
-
-
-# TODO: Name of the dataset usually match the script name with CamelCase instead of snake_case
-class PDBBindComplexes(datasets.ArrowBasedBuilder):
-    """List of protein sequences, ligand SMILES, and complex coordinates."""
-
-    VERSION = datasets.Version("1.5.0")
-
-    def _info(self):
-        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
-        #if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
-        #    features = datasets.Features(
-        #        {
-        #            "sentence": datasets.Value("string"),
-        #             "option1": datasets.Value("string"),
-        #            "answer": datasets.Value("string")
-        #            # These are the features of your dataset like images, labels ...
-        #        }
-        #    )
-        #else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
-        features = datasets.Features(
-            {
-                "name": datasets.Value("string"),
-                "seq": datasets.Value("string"),
-                "smiles": datasets.Value("string"),
-                "receptor_xyz": datasets.Sequence(datasets.Sequence(datasets.Value('float32'))),
-                "ligand_xyz": datasets.Sequence(datasets.Sequence(datasets.Value('float32'))),
-                "ligand_rot": datasets.Sequence(datasets.Sequence(datasets.Value('float32'))),
-                "receptor_rot": datasets.Sequence(datasets.Sequence(datasets.Value('float32'))),
-                # These are the features of your dataset like images, labels ...
-            }
-        )
-        return datasets.DatasetInfo(
-            # This is the description that will appear on the datasets page.
-            description=_DESCRIPTION,
-            # This defines the different columns of the dataset and their types
-            features=features,  # Here we define them above because they are different between the two configurations
-            # If there's a common (input, target) tuple from the features,
-            # specify them here. They'll be used if as_supervised=True in
-            # builder.as_dataset.
-            supervised_keys=None,
-            # Homepage of the dataset for documentation
-            homepage=_HOMEPAGE,
-            # License for the dataset if available
-            license=_LICENSE,
-            # Citation for the dataset
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-        # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
-        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
-
-        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLs
-        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
-        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
-        files = dl_manager.download_and_extract(_URLs)
-
-        return [
-            datasets.SplitGenerator(
-                # These kwargs will be passed to _generate_examples
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    'filepath': files["default"],
-                },
-            ),
-
-        ]
-
-    def _generate_tables(
-        self, filepath
-    ):
-        from pyarrow import fs
-        local = fs.LocalFileSystem()
-
-        for i, f in enumerate([filepath]):
-            yield i, pq.read_table(f,filesystem=local)