initial data upload

.gitignore

@@ -0,0 +1,18 @@
+env/
+.DS_Store
+affinity-data-combined.parquet
+protein_average_similarities.csv
+protein_maximum_similarities.csv
+protein_similarity_matrix.pkl
+test_25_targets_40_percent_similarity.parquet
+test_25_targets_60_percent_similarity.parquet
+test_25_targets_80_percent_similarity.parquet
+test_1000_drugs.parquet
+train.parquet
+test.parquet
+create_unseen_datasets.ipynb
+create_unseen_datasets.py
+dataset_trustworthiness.py
+combine_data.py
+temp.ipynb
+affinity_ranges_histogram.png

README.md

@@ -1,3 +1,89 @@
----
-license: mit
----
+---
+license: mit
+tags:
+- binding-affinity
+- biology
+- chemistry
+pretty_name: Binding Affinity
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: "glaser.parquet"
+  - split: val
+    path: "pdbbind-2013-core.parquet"
+  - split: davis
+    path: "davis.parquet"
+  - split: davis_filtered
+    path: "davis-filtered.parquet"
+  - split: kiba
+    path: "kiba.parquet"
+  - split: pdbbind_2020_general
+    path: "pdbbind-2020-general.parquet"
+  - split: pdbbind_2020_refined
+    path: "pdbbind-2020-refined.parquet"
+  - split: pdbbind_2013_core
+    path: "pdbbind-2013-core.parquet"
+  - split: bindingdb_ic50
+    path: "bindingdb-ic50.parquet"
+  - split: bindingdb_ki
+    path: "bindingdb-ki.parquet"
+  - split: bindingdb_kd_filtered
+    path: "bindingdb-kd-filtered.parquet"
+  - split: bindingdb_kd
+    path: "bindingdb-kd.parquet"
+  - split: glaser
+    path: "glaser.parquet"
+---
+
+# Binding Affinity Dataset
+
+## Overview
+
+This dataset is a comprehensive collection of protein-ligand binding affinity data, compiled from multiple sources. The dataset is structured with multiple splits, each corresponding to a specific source:
+
+- train split (glaser.parquet)
+- val split (pdbbind-2013-core.parquet)
+- davis split
+- davis_filtered split
+- kiba split
+- pdbbind_2020_general split
+- pdbbind_2020_refined split
+- pdbbind_2013_core split
+- bindingdb_ic50 split
+- bindingdb_ki split
+- bindingdb_kd_filtered split
+- bindingdb_kd split
+- glaser split
+
+## Training Dataset Composition
+
+The training split uses the Glaser dataset, while the validation split uses the PDBBind 2013 Core dataset.
+
+## Data Sources
+
+| Dataset | Source | Notes |
+|---------|--------|-------|
+| bindingdb_ic50.parquet | [TDC Python Package](https://tdcommons.ai/) | Therapeutic Data Commons |
+| bindingdb_kd.parquet | [TDC Python Package](https://tdcommons.ai/) | Therapeutic Data Commons |
+| bindingdb_kd_filtered.parquet | Manually Filtered | See `standardize_data.ipynb` |
+| bindingdb_ki.parquet | [TDC Python Package](https://tdcommons.ai/) | Therapeutic Data Commons |
+| davis.parquet | [TDC Python Package](https://tdcommons.ai/) | Therapeutic Data Commons |
+| davis_filtered.parquet | [Kaggle Dataset](https://www.kaggle.com/datasets/christang0002/davis-and-kiba) | Filtered Davis dataset |
+| kiba.parquet | [TDC Python Package](https://tdcommons.ai/) | Therapeutic Data Commons |
+| pdbbind_2020_general.parquet | [PDBBind](https://www.pdbbind.org.cn/) | General PDBBind 2020 dataset |
+| pdbbind_2020_refined.parquet | [PDBBind](https://www.pdbbind.org.cn/) | Refined PDBBind 2020 dataset |
+| pdbbind_2013_core.parquet | [PDBBind](https://www.pdbbind.org.cn/) | Core PDBBind 2013 dataset |
+| glaser.parquet | [HuggingFace Dataset](https://huggingface.co/datasets/jglaser/binding_affinity) | Glaser binding affinity dataset |
+
+## Dataset Columns
+
+| Column | Description |
+|--------|-------------|
+| `seq` | Protein sequence |
+| `smiles_can` | Canonical SMILES representation of the ligand |
+| `affinity_uM` | Binding affinity in micromolar (µM) concentration |
+| `neg_log10_affinityM` | Negative logarithm (base 10) of the affinity in molar concentration |
+| `affinity_norm` | Normalized binding affinity |
+| `affinity_mean` | Mean binding affinity for duplicate protein-ligand pairs |
+| `affinity_std` | Standard deviation of binding affinity for duplicate protein-ligand pairs |

bindingdb-ic50.parquet

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

bindingdb-kd-filtered.parquet

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

bindingdb-kd.parquet

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

bindingdb-ki.parquet

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

davis-filtered.parquet

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

davis.parquet

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

glaser.parquet

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

kiba.parquet

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

pdbbind-2013-core.parquet

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

pdbbind-2020-general.parquet

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

pdbbind-2020-refined.parquet

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

standardize_data.ipynb

@@ -0,0 +1,525 @@
+{
+ "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": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Processing PDBbind data: 100%|██████████| 195/195 [00:03<00:00, 49.05it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved 195 entries to pdbbind_2013_core.parquet\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "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 = \"path/to/PDBbind_v2020_refined\"\n",
+    "index_refined_file = \"/path/to/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 = \"/path/to/PDBbind_v2020_other_PL\"\n",
+    "index_general_file = \"/path/to/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": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Combined set size: 19280\n",
+      "Refined set size: 5312\n",
+      "General set size: 13941\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Read the combined and refined datasets\n",
+    "pdbbind_combined = pd.read_parquet('pdbbind-2020-combined.parquet')\n",
+    "pdbbind_refined = pd.read_parquet('pdbbind-2020-refined.parquet')\n",
+    "\n",
+    "# Find rows in combined that are not in refined by comparing seq and smiles_can pairs\n",
+    "general_set = pdbbind_combined[~pdbbind_combined.set_index(['seq', 'smiles_can']).index.isin(\n",
+    "    pdbbind_refined.set_index(['seq', 'smiles_can']).index\n",
+    ")].reset_index(drop=True)\n",
+    "\n",
+    "print(f\"Combined set size: {len(pdbbind_combined)}\")\n",
+    "print(f\"Refined set size: {len(pdbbind_refined)}\")\n",
+    "print(f\"General set size: {len(general_set)}\")\n",
+    "\n",
+    "# Save the general set\n",
+    "general_set.to_parquet('pdbbind-2020-general.parquet', index=False)\n"
+   ]
+  },
+  {
+   "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": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean affinity for glaser.parquet: 6.51\n",
+      "Mean affinity for bindingdb-ki.parquet: 6.88\n",
+      "Mean affinity for train.parquet: 6.46\n",
+      "Mean affinity for kiba.parquet: 7.93\n",
+      "Mean affinity for bindingdb-kd-filtered.parquet: 6.50\n",
+      "Mean affinity for pdbbind-2020-combined.parquet: 6.36\n",
+      "Mean affinity for pdbbind-2020-refined.parquet: 6.39\n",
+      "Mean affinity for test_25_targets_40_percent_similarity.parquet: 5.69\n",
+      "Mean affinity for test_1000_drugs.parquet: 6.38\n",
+      "Mean affinity for davis-filtered.parquet: 6.49\n",
+      "Mean affinity for bindingdb-ic50.parquet: 6.37\n",
+      "Mean affinity for test_25_targets_80_percent_similarity.parquet: 5.73\n",
+      "Mean affinity for bindingdb-kd.parquet: 5.81\n",
+      "Mean affinity for davis.parquet: 5.41\n",
+      "Mean affinity for test_25_targets_60_percent_similarity.parquet: 6.75\n",
+      "Mean affinity for affinity-data-combined.parquet: 6.46\n"
+     ]
+    }
+   ],
+   "source": [
+    "import glob\n",
+    "import pandas as pd\n",
+    "# Print mean affinity values for each dataset\n",
+    "parquet_files = glob.glob('*.parquet')\n",
+    "\n",
+    "for parquet_file in parquet_files:\n",
+    "    try:\n",
+    "        df = pd.read_parquet(parquet_file)\n",
+    "        if 'neg_log10_affinity_M' in df.columns:\n",
+    "            mean_affinity = df['neg_log10_affinity_M'].mean()\n",
+    "            print(f\"Mean affinity for {parquet_file}: {mean_affinity:.2f}\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"Could not process {parquet_file}: {str(e)}\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Combined dataset statistics:\n",
+      "Mean affinity: 6.5416\n",
+      "Standard deviation: 1.5625\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# Load the combined dataset\n",
+    "df = pd.read_parquet('affinity-data-combined.parquet')\n",
+    "\n",
+    "# Calculate mean and std dev\n",
+    "mean_affinity = df['neg_log10_affinity_M'].mean()\n",
+    "std_affinity = df['neg_log10_affinity_M'].std()\n",
+    "\n",
+    "print(f\"Combined dataset statistics:\")\n",
+    "print(f\"Mean affinity: {mean_affinity:.4f}\")\n",
+    "print(f\"Standard deviation: {std_affinity:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "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
+}