File size: 48,176 Bytes
4d1a63f 5ee44a9 4d1a63f 5ee44a9 4d1a63f |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 |
{
"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_parquet(\"data/bindingdb-ic50.parquet\", 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": 96,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Converted bindingdb-ki.csv to bindingdb-ki.parquet\n",
"Converted pdbbind-2020-refined.csv to pdbbind-2020-refined.parquet\n",
"Converted davis-filtered.csv to davis-filtered.parquet\n",
"Converted bindingdb-kd-filtered.csv to bindingdb-kd-filtered.parquet\n",
"Converted glaser.csv to glaser.parquet\n",
"Converted bindingdb-ic50.csv to bindingdb-ic50.parquet\n",
"Converted pdbbind-2020-combined.csv to pdbbind-2020-combined.parquet\n",
"Converted bindingdb-kd.csv to bindingdb-kd.parquet\n",
"Converted davis.csv to davis.parquet\n",
"Converted kiba.csv to kiba.parquet\n"
]
}
],
"source": [
"import pandas as pd\n",
"import glob\n",
"\n",
"# Get all CSV files in current directory\n",
"csv_files = glob.glob('*.csv')\n",
"\n",
"# Convert each CSV to parquet\n",
"for csv_file in csv_files:\n",
" # Read CSV\n",
" df = pd.read_csv(csv_file)\n",
" \n",
" # Create parquet filename by replacing .csv extension\n",
" parquet_file = csv_file.replace('.csv', '.parquet')\n",
" \n",
" # Save as parquet\n",
" df.to_parquet(parquet_file, index=False)\n",
" print(f\"Converted {csv_file} to {parquet_file}\")"
]
},
{
"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
}
|