filtered data, combined dataset

.gitattributes

@@ -66,3 +66,6 @@ davis-filter.csv filter=lfs diff=lfs merge=lfs -text
 bindingdb-ki.csv filter=lfs diff=lfs merge=lfs -text
 glaser.csv filter=lfs diff=lfs merge=lfs -text
 pdbbind-2020-combined.csv filter=lfs diff=lfs merge=lfs -text
+affinity-data-combined.parquet filter=lfs diff=lfs merge=lfs -text
+bindingdb-kd-filtered.csv filter=lfs diff=lfs merge=lfs -text
+davis-filtered.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+env/

affinity-data-combined.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a564ab56f845c9c4849d2c55e173e0ad53e873bdffc5c438eea064941663ea89
+size 1787700177

bindingdb-kd-filtered.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:541f7d1392c64a8b74f51bc08dbc5f8c619d832cb1a982f6f5d45837890adef7
+size 29878994

combine_data.py

@@ -0,0 +1,16 @@
+import pandas as pd
+
+def combine_csv_files(csv_file_list):
+    # Read and combine all CSV files into a single dataframe
+    combined_df = pd.concat([pd.read_csv(file) for file in csv_file_list], ignore_index=True)
+    
+    # Remove duplicate rows
+    combined_df = combined_df.drop_duplicates()
+    
+    # Sort by neg_log10_affinity_M
+    combined_df = combined_df.sort_values('neg_log10_affinity_M', ascending=False)
+    
+    return combined_df
+
+combined_df = combine_csv_files(['glaser.csv', 'davis-filtered.csv', 'pdbbind-2020-combined.csv', 'bindingdb-kd-filtered.csv', 'bindingdb-ki.csv', 'bindingdb-ic50.csv'])
+combined_df.to_parquet('affinity-data-combined.parquet', index=False)

data_sources.md

@@ -1,8 +1,9 @@
-davis-filter.csv: https://www.kaggle.com/datasets/christang0002/davis-and-kiba
 bindingdb-ic50.csv: https://tdcommons.ai/ (tdc python package)
 bindingdb-kd.csv: https://tdcommons.ai/ (tdc python package)
+bindingdb-kd-filtered.csv: filtered manually (see standardize_data.ipynb)
 bindingdb-ki.csv: https://tdcommons.ai/ (tdc python package)
 davis.csv: https://tdcommons.ai/ (tdc python package)
+davis-filtered.csv: https://www.kaggle.com/datasets/christang0002/davis-and-kiba
 kiba.csv: https://tdcommons.ai/ (tdc python package)
 pdbbind-2020-combined.csv: https://www.pdbbind.org.cn/
 pdbbind-2020-refined.csv: https://www.pdbbind.org.cn/

standardize_data.ipynb

@@ -0,0 +1,355 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Standardizing Datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from rdkit import Chem\n",
+    "from rdkit.Chem import MolToSmiles\n",
+    "from scipy.stats import zscore\n",
+    "from tqdm import tqdm\n",
+    "import numpy as np\n",
+    "\n",
+    "def load_binding_affinity_dataset(csv_path, \n",
+    "                                  protein_col_idx, \n",
+    "                                  smiles_col_idx, \n",
+    "                                  affinity_col_idx, \n",
+    "                                  is_log10_affinity=True, \n",
+    "                                  canonicalize_smiles=True, \n",
+    "                                  affinity_unit=\"uM\",\n",
+    "                                  delimiter=','):\n",
+    "    \"\"\"\n",
+    "    Load a protein-ligand binding affinity dataset and preprocess it.\n",
+    "\n",
+    "    Args:\n",
+    "        csv_path (str): Path to the CSV file.\n",
+    "        protein_col_idx (int): Column index containing protein sequences.\n",
+    "        smiles_col_idx (int): Column index containing molecule SMILES.\n",
+    "        affinity_col_idx (int): Column index containing binding affinities.\n",
+    "        is_log10_affinity (bool): Whether affinities are in log10. Default is True.\n",
+    "        canonicalize_smiles (bool): Whether to canonicalize SMILES. Default is True.\n",
+    "        delimiter (str): Delimiter for the CSV file. Default is ','.\n",
+    "\n",
+    "    Returns:\n",
+    "        pd.DataFrame: Processed DataFrame with columns \"seq\", \"smiles_can\",\n",
+    "                      \"affinity_uM\", \"neg_log10_affinity_M\", and \"affinity_norm\".\n",
+    "    \"\"\"\n",
+    "    # Load dataset\n",
+    "    df = pd.read_csv(csv_path, delimiter=delimiter)\n",
+    "\n",
+    "    # Extract relevant columns\n",
+    "    df = df.iloc[:, [protein_col_idx, smiles_col_idx, affinity_col_idx]]\n",
+    "    df.columns = [\"seq\", \"smiles\", \"affinity\"]\n",
+    "\n",
+    "    # Canonicalize SMILES\n",
+    "    if canonicalize_smiles:\n",
+    "        def canonicalize(smiles):\n",
+    "            try:\n",
+    "                mol = Chem.MolFromSmiles(smiles)\n",
+    "                return MolToSmiles(mol, canonical=True) if mol else None\n",
+    "            except:\n",
+    "                return None\n",
+    "\n",
+    "        from tqdm import tqdm\n",
+    "        tqdm.pandas()\n",
+    "        df[\"smiles_can\"] = df[\"smiles\"].progress_apply(canonicalize)\n",
+    "        df = df[df[\"smiles_can\"].notna()]\n",
+    "    else:\n",
+    "        df[\"smiles_can\"] = df[\"smiles\"]\n",
+    "\n",
+    "    # Process affinities\n",
+    "    if not is_log10_affinity:\n",
+    "        # Convert plain Kd value to neg log10(M)\n",
+    "        df[\"affinity_uM\"] = df[\"affinity\"]/(1e3 if affinity_unit == \"nM\" else 1)\n",
+    "        \n",
+    "        df[\"neg_log10_affinity_M\"] = -df[\"affinity_uM\"].apply(lambda x: np.log10(x/1e6) if x > 0 else np.nan)\n",
+    "    else:\n",
+    "        # Convert log10 values to plain uM for clarity\n",
+    "        df[\"neg_log10_affinity_M\"] = df[\"affinity\"]\n",
+    "        df[\"affinity_uM\"] = df[\"neg_log10_affinity_M\"].apply(lambda x: (10**(-x))*1e6)\n",
+    "\n",
+    "    df.dropna(inplace=True)\n",
+    "\n",
+    "    # Z-score normalization\n",
+    "    df[\"affinity_norm\"] = zscore(df[\"neg_log10_affinity_M\"])\n",
+    "\n",
+    "    # Select and reorder columns\n",
+    "    df = df[[\"seq\", \"smiles_can\", \"affinity_uM\", \"neg_log10_affinity_M\", \"affinity_norm\"]]\n",
+    "\n",
+    "    # Add normalization parameters as columns for reference\n",
+    "    df[\"affinity_mean\"] = df[\"neg_log10_affinity_M\"].mean()\n",
+    "    df[\"affinity_std\"] = df[\"neg_log10_affinity_M\"].std()\n",
+    "\n",
+    "    return df.sort_values(by=\"affinity_norm\", ascending=False)\n",
+    "\n",
+    "dataset = load_binding_affinity_dataset(\n",
+    "    csv_path=\"data/raw_data/bindingdb_ic50.csv\",\n",
+    "    protein_col_idx=3,\n",
+    "    smiles_col_idx=1,\n",
+    "    affinity_col_idx=4,\n",
+    "    is_log10_affinity=False,  # Specify if Kd values are plain\n",
+    "    canonicalize_smiles=True,\n",
+    "    affinity_unit=\"nM\",\n",
+    "    delimiter=\",\"\n",
+    ")\n",
+    "dataset.to_csv(\"data/bindingdb-ic50.csv\", index=False)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## TDC Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from rdkit import Chem\n",
+    "from tdc.multi_pred import DTI\n",
+    "\n",
+    "def process_dataset(name):\n",
+    "    data = DTI(name=name)\n",
+    "    data.harmonize_affinities(mode='mean')\n",
+    "    data.convert_to_log()\n",
+    "    df = data.get_data()\n",
+    "    df['smiles_can'] = df['Drug'].apply(lambda s: Chem.MolToSmiles(Chem.MolFromSmiles(s), isomericSmiles=True, canonical=True) if Chem.MolFromSmiles(s) else None)\n",
+    "    return df[['smiles_can', 'Target', 'Y']].dropna(subset=['smiles_can']).rename(columns={'Target': 'seq', 'Y': 'neg_log_10_affinity'})\n",
+    "\n",
+    "datasets = ['BindingDB_Ki', 'BindingDB_Kd', 'BindingDB_IC50', 'DAVIS', 'KIBA']\n",
+    "processed_data = [process_dataset(name) for name in datasets]\n",
+    "\n",
+    "binding_db = pd.concat(processed_data[:3]).drop_duplicates().reset_index(drop=True)\n",
+    "binding_db.to_csv(\"data/bindingdb.csv\", index=False)\n",
+    "processed_data[3].to_csv(\"data/davis.csv\", index=False)\n",
+    "processed_data[4].to_csv(\"data/kiba.csv\", index=False)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## PDBbind"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from pathlib import Path\n",
+    "from Bio import PDB\n",
+    "from Bio.PDB.Polypeptide import PPBuilder\n",
+    "from rdkit import Chem\n",
+    "from rdkit.Chem import AllChem\n",
+    "import pandas as pd\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "ppb = PPBuilder()\n",
+    "\n",
+    "def get_protein_sequence(structure):\n",
+    "    \"\"\"Extract protein sequence from a PDB structure.\"\"\"\n",
+    "    sequence = \"\"\n",
+    "    for pp in ppb.build_peptides(structure):\n",
+    "        sequence += str(pp.get_sequence())\n",
+    "    return sequence\n",
+    "\n",
+    "def get_canonical_smiles(mol):\n",
+    "    \"\"\"Convert RDKit molecule to canonical SMILES.\"\"\"\n",
+    "    return Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)\n",
+    "\n",
+    "def process_pdbbind_data(pdbbind_dir, index_file):\n",
+    "    pdbbind_dir = Path(pdbbind_dir).expanduser()\n",
+    "    parser = PDB.PDBParser(QUIET=True)\n",
+    "    data = []\n",
+    "\n",
+    "    # Read the index file\n",
+    "    df_index = pd.read_csv(index_file, sep='\\s+', header=None, comment= \"#\", usecols=[0,1,2,3,4,6,7],\n",
+    "                           names=['PDB_ID', 'Resolution', 'Release_Year', '-logKd/Ki', 'Kd/Ki', 'Reference', 'Ligand_Name'])\n",
+    "\n",
+    "    # Get the total number of entries for progress tracking\n",
+    "    total_entries = len(df_index)\n",
+    "\n",
+    "    # Use tqdm for progress tracking\n",
+    "    with tqdm(total=total_entries, desc=\"Processing PDBbind data\") as pbar:\n",
+    "        for _, row in df_index.iterrows():\n",
+    "            pdb_id = row['PDB_ID']\n",
+    "            subdir = pdbbind_dir / pdb_id\n",
+    "\n",
+    "            if subdir.is_dir():\n",
+    "                # Process protein\n",
+    "                protein_file = subdir / f\"{pdb_id}_protein.pdb\"\n",
+    "                if protein_file.exists():\n",
+    "                    structure = parser.get_structure(pdb_id, protein_file)\n",
+    "                    sequence = get_protein_sequence(structure)\n",
+    "\n",
+    "                # Process ligand\n",
+    "                ligand_file = subdir / f\"{pdb_id}_ligand.mol2\"\n",
+    "                if ligand_file.exists():\n",
+    "                    mol = Chem.MolFromMol2File(str(ligand_file))\n",
+    "                    if mol is not None:\n",
+    "                        smiles = get_canonical_smiles(mol)\n",
+    "\n",
+    "                        # Get binding affinity\n",
+    "                        neg_log_10_affinity = row['-logKd/Ki']\n",
+    "\n",
+    "                        # Add to data list\n",
+    "                        data.append({\n",
+    "                            'smiles_can': smiles,\n",
+    "                            'seq': sequence,\n",
+    "                            'neg_log_10_affinity_M': neg_log_10_affinity\n",
+    "                        })\n",
+    "\n",
+    "            pbar.update(1)\n",
+    "\n",
+    "    return pd.DataFrame(data)\n",
+    "\n",
+    "# Process data from PDBbind refined set\n",
+    "pdbbind_refined_dir = \"~/Data/PDBBind/PDBbind_v2020_refined\"\n",
+    "index_refined_file = \"/home/tyler/Data/PDBBind/index/INDEX_refined_data.2020\"\n",
+    "df_refined = process_pdbbind_data(pdbbind_refined_dir, index_refined_file)\n",
+    "\n",
+    "# Process data from PDBbind general set\n",
+    "pdbbind_general_dir = \"~/Data/PDBBind/PDBbind_v2020_other_PL\"\n",
+    "index_general_file = \"/home/tyler/Data/PDBBind/index/INDEX_general_PL_data.2020\"\n",
+    "df_general = process_pdbbind_data(pdbbind_general_dir, index_general_file)\n",
+    "\n",
+    "# Combine dataframes\n",
+    "df_combined = pd.concat([df_refined, df_general], ignore_index=True)\n",
+    "\n",
+    "# Remove duplicates (if any) and reset index\n",
+    "df_combined = df_combined.drop_duplicates().reset_index(drop=True)\n",
+    "\n",
+    "# Save to CSV\n",
+    "output_file = \"data/pdbbind_2020_combined.csv\"\n",
+    "df_combined.to_csv(output_file, index=False)\n",
+    "print(f\"Saved {len(df_combined)} entries to {output_file}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Filtering bindingdb-kd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mode of neg_log10_affinity_M in BindingDB IC50 dataset: 5.00\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of entries after filtering: 35845\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from statistics import mode\n",
+    "# Read the bindingdb-ic50 dataset\n",
+    "bindingdb_df = pd.read_csv('bindingdb-kd.csv')\n",
+    "\n",
+    "# Calculate the mode of neg_log10_affinity_M\n",
+    "mode_affinity = mode([x for x in bindingdb_df['neg_log10_affinity_M'].tolist()])\n",
+    "# Visualize before filtering\n",
+    "plt.hist(bindingdb_df['neg_log10_affinity_M'], bins=30, alpha=0.7)\n",
+    "plt.title('Before Filtering')\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"Mode of neg_log10_affinity_M in BindingDB IC50 dataset: {mode_affinity:.2f}\")\n",
+    "\n",
+    "# set seed\n",
+    "np.random.seed(42)\n",
+    "# Filter out 90% of rows where neg_log10_affinity_M equals 5\n",
+    "mask_value_5 = bindingdb_df['neg_log10_affinity_M'] == 5\n",
+    "rows_to_keep = ~mask_value_5 | (mask_value_5 & (np.random.rand(len(bindingdb_df)) < 0.05))\n",
+    "bindingdb_df = bindingdb_df[rows_to_keep].reset_index(drop=True)\n",
+    "\n",
+    "# Visualize after filtering\n",
+    "plt.hist(bindingdb_df['neg_log10_affinity_M'], bins=30, alpha=0.7)\n",
+    "plt.title('After Filtering')\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"Number of entries after filtering: {len(bindingdb_df)}\")\n",
+    "\n",
+    "bindingdb_df.to_csv('bindingdb-kd-filtered.csv', index=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "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.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

standardize_data.py

@@ -1,205 +0,0 @@
-import pandas as pd
-from rdkit import Chem
-from rdkit.Chem import MolToSmiles
-from scipy.stats import zscore
-from tqdm import tqdm
-import numpy as np
-
-def load_binding_affinity_dataset(csv_path, 
-                                  protein_col_idx, 
-                                  smiles_col_idx, 
-                                  affinity_col_idx, 
-                                  is_log10_affinity=True, 
-                                  canonicalize_smiles=True, 
-                                  affinity_unit="uM",
-                                  delimiter=','):
-    """
-    Load a protein-ligand binding affinity dataset and preprocess it.
-
-    Args:
-        csv_path (str): Path to the CSV file.
-        protein_col_idx (int): Column index containing protein sequences.
-        smiles_col_idx (int): Column index containing molecule SMILES.
-        affinity_col_idx (int): Column index containing binding affinities.
-        is_log10_affinity (bool): Whether affinities are in log10. Default is True.
-        canonicalize_smiles (bool): Whether to canonicalize SMILES. Default is True.
-        delimiter (str): Delimiter for the CSV file. Default is ','.
-
-    Returns:
-        pd.DataFrame: Processed DataFrame with columns "seq", "smiles_can",
-                      "affinity_uM", "neg_log10_affinity_M", and "affinity_norm".
-    """
-    # Load dataset
-    df = pd.read_csv(csv_path, delimiter=delimiter)
-
-    # Extract relevant columns
-    df = df.iloc[:, [protein_col_idx, smiles_col_idx, affinity_col_idx]]
-    df.columns = ["seq", "smiles", "affinity"]
-
-    # Canonicalize SMILES
-    if canonicalize_smiles:
-        def canonicalize(smiles):
-            try:
-                mol = Chem.MolFromSmiles(smiles)
-                return MolToSmiles(mol, canonical=True) if mol else None
-            except:
-                return None
-
-        from tqdm import tqdm
-        tqdm.pandas()
-        df["smiles_can"] = df["smiles"].progress_apply(canonicalize)
-        df = df[df["smiles_can"].notna()]
-    else:
-        df["smiles_can"] = df["smiles"]
-
-    # Process affinities
-    if not is_log10_affinity:
-        # Convert plain Kd value to neg log10(M)
-        df["affinity_uM"] = df["affinity"]/(1e3 if affinity_unit == "nM" else 1)
-        
-        df["neg_log10_affinity_M"] = -df["affinity_uM"].apply(lambda x: np.log10(x/1e6) if x > 0 else np.nan)
-    else:
-        # Convert log10 values to plain uM for clarity
-        df["neg_log10_affinity_M"] = df["affinity"]
-        df["affinity_uM"] = df["neg_log10_affinity_M"].apply(lambda x: (10**(-x))*1e6)
-
-    df.dropna(inplace=True)
-
-    # Z-score normalization
-    df["affinity_norm"] = zscore(df["neg_log10_affinity_M"])
-
-    # Select and reorder columns
-    df = df[["seq", "smiles_can", "affinity_uM", "neg_log10_affinity_M", "affinity_norm"]]
-
-    # Add normalization parameters as columns for reference
-    df["affinity_mean"] = df["neg_log10_affinity_M"].mean()
-    df["affinity_std"] = df["neg_log10_affinity_M"].std()
-
-    return df.sort_values(by="affinity_norm", ascending=False)
-
-dataset = load_binding_affinity_dataset(
-    csv_path="data/raw_data/bindingdb_ic50.csv",
-    protein_col_idx=3,
-    smiles_col_idx=1,
-    affinity_col_idx=4,
-    is_log10_affinity=False,  # Specify if Kd values are plain
-    canonicalize_smiles=True,
-    affinity_unit="nM",
-    delimiter=","
-)
-dataset.to_csv("data/bindingdb-ic50.csv", index=False)
-
-# View processed dataset
-print(dataset.head())
-
-
-# Code for loading tdc data:
-# import pandas as pd
-# from rdkit import Chem
-# from tdc.multi_pred import DTI
-
-# def process_dataset(name):
-#     data = DTI(name=name)
-#     data.harmonize_affinities(mode='mean')
-#     data.convert_to_log()
-#     df = data.get_data()
-#     df['smiles_can'] = df['Drug'].apply(lambda s: Chem.MolToSmiles(Chem.MolFromSmiles(s), isomericSmiles=True, canonical=True) if Chem.MolFromSmiles(s) else None)
-#     return df[['smiles_can', 'Target', 'Y']].dropna(subset=['smiles_can']).rename(columns={'Target': 'seq', 'Y': 'neg_log_10_affinity'})
-
-# datasets = ['BindingDB_Ki', 'BindingDB_Kd', 'BindingDB_IC50', 'DAVIS', 'KIBA']
-# processed_data = [process_dataset(name) for name in datasets]
-
-# binding_db = pd.concat(processed_data[:3]).drop_duplicates().reset_index(drop=True)
-# binding_db.to_csv("data/bindingdb.csv", index=False)
-# processed_data[3].to_csv("data/davis.csv", index=False)
-# processed_data[4].to_csv("data/kiba.csv", index=False)
-
-# code for loading pdbbind data:
-# import os
-# from pathlib import Path
-# from Bio import PDB
-# from Bio.PDB.Polypeptide import PPBuilder
-# from rdkit import Chem
-# from rdkit.Chem import AllChem
-# import pandas as pd
-# from tqdm import tqdm
-
-# ppb = PPBuilder()
-
-# def get_protein_sequence(structure):
-#     """Extract protein sequence from a PDB structure."""
-#     sequence = ""
-#     for pp in ppb.build_peptides(structure):
-#         sequence += str(pp.get_sequence())
-#     return sequence
-
-# def get_canonical_smiles(mol):
-#     """Convert RDKit molecule to canonical SMILES."""
-#     return Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
-
-# def process_pdbbind_data(pdbbind_dir, index_file):
-#     pdbbind_dir = Path(pdbbind_dir).expanduser()
-#     parser = PDB.PDBParser(QUIET=True)
-#     data = []
-
-#     # Read the index file
-#     df_index = pd.read_csv(index_file, sep='\s+', header=None, comment= "#", usecols=[0,1,2,3,4,6,7],
-#                            names=['PDB_ID', 'Resolution', 'Release_Year', '-logKd/Ki', 'Kd/Ki', 'Reference', 'Ligand_Name'])
-
-#     # Get the total number of entries for progress tracking
-#     total_entries = len(df_index)
-
-#     # Use tqdm for progress tracking
-#     with tqdm(total=total_entries, desc="Processing PDBbind data") as pbar:
-#         for _, row in df_index.iterrows():
-#             pdb_id = row['PDB_ID']
-#             subdir = pdbbind_dir / pdb_id
-
-#             if subdir.is_dir():
-#                 # Process protein
-#                 protein_file = subdir / f"{pdb_id}_protein.pdb"
-#                 if protein_file.exists():
-#                     structure = parser.get_structure(pdb_id, protein_file)
-#                     sequence = get_protein_sequence(structure)
-
-#                 # Process ligand
-#                 ligand_file = subdir / f"{pdb_id}_ligand.mol2"
-#                 if ligand_file.exists():
-#                     mol = Chem.MolFromMol2File(str(ligand_file))
-#                     if mol is not None:
-#                         smiles = get_canonical_smiles(mol)
-
-#                         # Get binding affinity
-#                         neg_log_10_affinity = row['-logKd/Ki']
-
-#                         # Add to data list
-#                         data.append({
-#                             'smiles_can': smiles,
-#                             'seq': sequence,
-#                             'neg_log_10_affinity_M': neg_log_10_affinity
-#                         })
-
-#             pbar.update(1)
-
-#     return pd.DataFrame(data)
-
-# # Process data from PDBbind refined set
-# pdbbind_refined_dir = "~/Data/PDBBind/PDBbind_v2020_refined"
-# index_refined_file = "/home/tyler/Data/PDBBind/index/INDEX_refined_data.2020"
-# df_refined = process_pdbbind_data(pdbbind_refined_dir, index_refined_file)
-
-# # Process data from PDBbind general set
-# pdbbind_general_dir = "~/Data/PDBBind/PDBbind_v2020_other_PL"
-# index_general_file = "/home/tyler/Data/PDBBind/index/INDEX_general_PL_data.2020"
-# df_general = process_pdbbind_data(pdbbind_general_dir, index_general_file)
-
-# # Combine dataframes
-# df_combined = pd.concat([df_refined, df_general], ignore_index=True)
-
-# # Remove duplicates (if any) and reset index
-# df_combined = df_combined.drop_duplicates().reset_index(drop=True)
-
-# # Save to CSV
-# output_file = "data/pdbbind_2020_combined.csv"
-# df_combined.to_csv(output_file, index=False)
-# print(f"Saved {len(df_combined)} entries to {output_file}")