diff --git a/notebooks/comparison/structure_distances_vs_dfg.ipynb b/notebooks/comparison/structure_distances_vs_dfg.ipynb index 6451cc9..5e304e5 100644 --- a/notebooks/comparison/structure_distances_vs_dfg.ipynb +++ b/notebooks/comparison/structure_distances_vs_dfg.ipynb @@ -4,7 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Influence of DFG conformation on structure distances" + "# Can fingerprint distances discriminate DFG conformations?\n", + "\n", + "The `kissim` fingerprint encodes the pocket residues' spatial distance to four centers—the pocket centroid, hinge region, DFG region and front pocket—and should therefore discriminate between two structures in different conformations; when we compare two structures in *different* conformations the fingerprint distance should be higher than for two structures in *similar* conformations.\n", + "\n", + "Let's check if this is true using DFG conformations from KLIFS. Plot distribution of fingerprint distances grouped by in/in, out/out, and in/out pairs.\n", + "\n", + "- Use fingerprint distances for structure pairs between all kinases\n", + "- Use fingerprint distances for structure pairs between the same kinase" ] }, { @@ -25,7 +32,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "de250f837c5842438c9d00f67fc311f9", + "model_id": "bd0eed98315c4609bccf279e27dd085d", "version_major": 2, "version_minor": 0 }, @@ -38,12 +45,13 @@ "source": [ "from pathlib import Path\n", "\n", - "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "from opencadd.databases.klifs import setup_local\n", + "from IPython.display import display, Markdown\n", + "from opencadd.databases.klifs import setup_remote\n", + "from kissim.comparison import FingerprintDistanceGenerator\n", "\n", - "from kissim.comparison import FingerprintDistanceGenerator" + "from src.definitions import COVERAGE_CUTOFF" ] }, { @@ -65,60 +73,38 @@ "plt.style.use(\"seaborn\")" ] }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "COVERAGE_CUTOFF = 0.8" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load structural metadata" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "klifs_session = setup_local(HERE / \"../../data/external/structures/20210114_KLIFS_HUMAN/\")\n", - "structures = klifs_session.structures.all_structures()" - ] - }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Load fingerprint distances" + "## Load fingerprint distances with sufficient coverage\n", + "\n", + "Choose fingerprint distances that are based on spatial distances only (weighting scheme: 010) and that are based on a sufficient pairwise fingerprint bit coverage (default: `COVERAGE_CUTOFF`)." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.8" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "fingerprint_distance_file = DATA / \"fingerprint_distances.csv\"" + "COVERAGE_CUTOFF" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -126,21 +112,11 @@ "output_type": "stream", "text": [ "Number of kinases: 292\n", - "Number of structures: 4916\n" + "Number of structures: 4916\n", + "Number of structure pairs: 12081070\n", + "Number of structure pairs: 11733382\n" ] - } - ], - "source": [ - "fingerprint_distance_generator = FingerprintDistanceGenerator.from_csv(fingerprint_distance_file)\n", - "print(f\"Number of kinases: {len(fingerprint_distance_generator.kinase_ids)}\")\n", - "print(f\"Number of structures: {len(fingerprint_distance_generator.structure_ids)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + }, { "data": { "text/html": [ @@ -177,8 +153,8 @@ " 6679\n", " AAK1\n", " AAK1\n", - " 0.051608\n", - " 0.992667\n", + " 0.053935\n", + " 1.0\n", " \n", " \n", " 1\n", @@ -186,8 +162,8 @@ " 7156\n", " AAK1\n", " AAK1\n", - " 0.059276\n", - " 0.991333\n", + " 0.065967\n", + " 1.0\n", " \n", " \n", " 2\n", @@ -195,8 +171,8 @@ " 1104\n", " AAK1\n", " ABL1\n", - " 0.275259\n", - " 0.990667\n", + " 0.146598\n", + " 1.0\n", " \n", " \n", " 3\n", @@ -204,8 +180,8 @@ " 1065\n", " AAK1\n", " ABL1\n", - " 0.284854\n", - " 0.990667\n", + " 0.150158\n", + " 1.0\n", " \n", " \n", " 4\n", @@ -213,8 +189,8 @@ " 1090\n", " AAK1\n", " ABL1\n", - " 0.262851\n", - " 0.990667\n", + " 0.126940\n", + " 1.0\n", " \n", " \n", "\n", @@ -222,20 +198,31 @@ ], "text/plain": [ " structure.1 structure.2 kinase.1 kinase.2 distance bit_coverage\n", - "0 3835 6679 AAK1 AAK1 0.051608 0.992667\n", - "1 3835 7156 AAK1 AAK1 0.059276 0.991333\n", - "2 3835 1104 AAK1 ABL1 0.275259 0.990667\n", - "3 3835 1065 AAK1 ABL1 0.284854 0.990667\n", - "4 3835 1090 AAK1 ABL1 0.262851 0.990667" + "0 3835 6679 AAK1 AAK1 0.053935 1.0\n", + "1 3835 7156 AAK1 AAK1 0.065967 1.0\n", + "2 3835 1104 AAK1 ABL1 0.146598 1.0\n", + "3 3835 1065 AAK1 ABL1 0.150158 1.0\n", + "4 3835 1090 AAK1 ABL1 0.126940 1.0" ] }, - "execution_count": 10, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "# Set path\n", + "fingerprint_distance_file = DATA / \"fingerprint_distances_010.csv\"\n", + "# Load data\n", + "fingerprint_distance_generator = FingerprintDistanceGenerator.from_csv(fingerprint_distance_file)\n", + "print(f\"Number of kinases: {len(fingerprint_distance_generator.kinase_ids)}\")\n", + "print(f\"Number of structures: {len(fingerprint_distance_generator.structure_ids)}\")\n", "structure_distances = fingerprint_distance_generator.data\n", + "print(f\"Number of structure pairs: {structure_distances.shape[0]}\")\n", + "structure_distances = structure_distances[\n", + " structure_distances[\"bit_coverage\"] >= COVERAGE_CUTOFF\n", + "].reset_index(drop=True)\n", + "print(f\"Number of structure pairs: {structure_distances.shape[0]}\")\n", "structure_distances.head()" ] }, @@ -243,45 +230,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Sort fingerprint/kinase pairs (alphabetically)" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "def sort_structure_pairs(row):\n", - " if row[\"structure.1\"] > row[\"structure.2\"]:\n", - " structure_tmp = row[\"structure.1\"]\n", - " row[\"structure.1\"] = row[\"structure.2\"]\n", - " row[\"structure.2\"] = structure_tmp\n", - " kinase_tmp = row[\"kinase.1\"]\n", - " row[\"kinase.1\"] = row[\"kinase.2\"]\n", - " row[\"kinase.2\"] = kinase_tmp\n", - " return row" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "%%time\n", - "structure_distances = structure_distances[:100000].apply(lambda x: sort_structure_pairs(x), axis=1)\n", - "structure_distances.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Filter distances by coverage cutoff" + "## Add DFG conformation\n", + "\n", + "Add DFG conformation from KLIFS to each structure pair." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1min 11s, sys: 477 ms, total: 1min 11s\n", + "Wall time: 1min 13s\n" + ] + }, { "data": { "text/html": [ @@ -309,7 +275,8 @@ " kinase.2\n", " distance\n", " bit_coverage\n", - " distance_filtered\n", + " dfg.1\n", + " dfg.2\n", " \n", " \n", " \n", @@ -319,9 +286,10 @@ " 6679\n", " AAK1\n", " AAK1\n", - " 0.051608\n", - " 0.992667\n", - " 0.051608\n", + " 0.053935\n", + " 1.0\n", + " in\n", + " in\n", " \n", " \n", " 1\n", @@ -329,9 +297,10 @@ " 7156\n", " AAK1\n", " AAK1\n", - " 0.059276\n", - " 0.991333\n", - " 0.059276\n", + " 0.065967\n", + " 1.0\n", + " in\n", + " in\n", " \n", " \n", " 2\n", @@ -339,9 +308,10 @@ " 1104\n", " AAK1\n", " ABL1\n", - " 0.275259\n", - " 0.990667\n", - " 0.275259\n", + " 0.146598\n", + " 1.0\n", + " in\n", + " out-like\n", " \n", " \n", " 3\n", @@ -349,9 +319,10 @@ " 1065\n", " AAK1\n", " ABL1\n", - " 0.284854\n", - " 0.990667\n", - " 0.284854\n", + " 0.150158\n", + " 1.0\n", + " in\n", + " out\n", " \n", " \n", " 4\n", @@ -359,126 +330,144 @@ " 1090\n", " AAK1\n", " ABL1\n", - " 0.262851\n", - " 0.990667\n", - " 0.262851\n", + " 0.126940\n", + " 1.0\n", + " in\n", + " in\n", " \n", " \n", "\n", "" ], "text/plain": [ - " structure.1 structure.2 kinase.1 kinase.2 distance bit_coverage \\\n", - "0 3835 6679 AAK1 AAK1 0.051608 0.992667 \n", - "1 3835 7156 AAK1 AAK1 0.059276 0.991333 \n", - "2 3835 1104 AAK1 ABL1 0.275259 0.990667 \n", - "3 3835 1065 AAK1 ABL1 0.284854 0.990667 \n", - "4 3835 1090 AAK1 ABL1 0.262851 0.990667 \n", + " structure.1 structure.2 kinase.1 kinase.2 distance bit_coverage dfg.1 \\\n", + "0 3835 6679 AAK1 AAK1 0.053935 1.0 in \n", + "1 3835 7156 AAK1 AAK1 0.065967 1.0 in \n", + "2 3835 1104 AAK1 ABL1 0.146598 1.0 in \n", + "3 3835 1065 AAK1 ABL1 0.150158 1.0 in \n", + "4 3835 1090 AAK1 ABL1 0.126940 1.0 in \n", "\n", - " distance_filtered \n", - "0 0.051608 \n", - "1 0.059276 \n", - "2 0.275259 \n", - "3 0.284854 \n", - "4 0.262851 " + " dfg.2 \n", + "0 in \n", + "1 in \n", + "2 out-like \n", + "3 out \n", + "4 in " ] }, - "execution_count": 11, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "structure_distances[\"distance_filtered\"] = np.where(\n", - " structure_distances[\"bit_coverage\"].values < COVERAGE_CUTOFF,\n", - " np.nan,\n", - " structure_distances[\"distance\"].values,\n", - ")\n", + "%%time\n", + "klifs_session = setup_remote()\n", + "structures = klifs_session.structures.all_structures()\n", + "dfg = structures.set_index(\"structure.klifs_id\")[\"structure.dfg\"]\n", + "structure_distances[\"dfg.1\"] = structure_distances[\"structure.1\"].apply(lambda x: dfg[x])\n", + "structure_distances[\"dfg.2\"] = structure_distances[\"structure.2\"].apply(lambda x: dfg[x])\n", "structure_distances.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot DFG conformation pairs\n", + "\n", + "Group the structure pairs by DFG conformation pairs—in/in, out/out, in/out—and plot their fingerprint distance distributions." + ] + }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Structure pairs: 12081070\n", - "Structure pairs not-NaN: 11964546\n" - ] - } - ], + "outputs": [], "source": [ - "print(f\"Structure pairs: {structure_distances.shape[0]}\")\n", - "structure_distances = structure_distances[structure_distances[\"distance_filtered\"].notna()]\n", - "print(f\"Structure pairs not-NaN: {structure_distances.shape[0]}\")" + "def structure_distances_by_dfg_conformation_pairs(structure_distances):\n", + " \"\"\"Distances for all, in/in, out/out, and in/out structure pairs.\"\"\"\n", + "\n", + " dfg_all = structure_distances[\"distance\"]\n", + " dfg_in_in = structure_distances[\n", + " (structure_distances[\"dfg.1\"] == \"in\") & (structure_distances[\"dfg.2\"] == \"in\")\n", + " ][\"distance\"]\n", + " dfg_out_out = structure_distances[\n", + " (structure_distances[\"dfg.1\"] == \"out\") & (structure_distances[\"dfg.2\"] == \"out\")\n", + " ][\"distance\"]\n", + " dfg_in_out = structure_distances[\n", + " ((structure_distances[\"dfg.1\"] == \"in\") & (structure_distances[\"dfg.2\"] == \"out\"))\n", + " | ((structure_distances[\"dfg.1\"] == \"out\") & (structure_distances[\"dfg.2\"] == \"in\"))\n", + " ][\"distance\"]\n", + "\n", + " structure_distances_dfg = pd.DataFrame(\n", + " {\"all\": dfg_all, \"in/in\": dfg_in_in, \"out/out\": dfg_out_out, \"in/out\": dfg_in_out}\n", + " )\n", + " structure_distances_dfg = pd.DataFrame(structure_distances_dfg)\n", + "\n", + " return structure_distances_dfg" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [], "source": [ - "## DFG conformation" + "def plot_structure_distances_by_dfg_conformation_pairs(structure_distances):\n", + " \"\"\"Plot distribution of structure distances per DFG conformation pair.\"\"\"\n", + "\n", + " # Data\n", + " structure_distances_dfg = structure_distances_by_dfg_conformation_pairs(structure_distances)\n", + " print(\"Number of structure pairs per conformation pair:\")\n", + " print(structure_distances_dfg.notna().sum())\n", + "\n", + " # Boxplot\n", + " structure_distances_dfg.plot(\n", + " kind=\"box\", title=\"Conformation dependent structure pair distances\"\n", + " )\n", + " plt.show()\n", + "\n", + " # Stats\n", + " display(structure_distances_dfg.describe())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Plot DFG-in vs. DFG-out" + "### All structures\n", + "\n", + "Use fingerprint distances for structure pairs between all kinases." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":2: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 2s, sys: 371 ms, total: 1min 2s\n", - "Wall time: 1min 2s\n" + "Number of structure pairs per conformation pair:\n", + "all 11733382\n", + "in/in 8674987\n", + "out/out 99967\n", + "in/out 1865839\n", + "dtype: int64\n" ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - ":3: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" - ] - } - ], - "source": [ - "%%time\n", - "dfg = structures.set_index(\"structure.klifs_id\")[\"structure.dfg\"]\n", - "structure_distances[\"dfg.1\"] = structure_distances[\"structure.1\"].apply(lambda x: dfg[x])\n", - "structure_distances[\"dfg.2\"] = structure_distances[\"structure.2\"].apply(lambda x: dfg[x])" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { "text/html": [ @@ -500,158 +489,327 @@ " \n", " \n", " \n", - " structure.1\n", - " structure.2\n", - " kinase.1\n", - " kinase.2\n", - " distance\n", - " bit_coverage\n", - " distance_filtered\n", - " dfg.1\n", - " dfg.2\n", + " all\n", + " in/in\n", + " out/out\n", + " in/out\n", " \n", " \n", " \n", " \n", - " 0\n", - " 3835\n", - " 6679\n", - " AAK1\n", - " AAK1\n", - " 0.051608\n", - " 0.992667\n", - " 0.051608\n", - " in\n", - " in\n", + " count\n", + " 1.173338e+07\n", + " 8.674987e+06\n", + " 99967.000000\n", + " 1.865839e+06\n", " \n", " \n", - " 1\n", - " 3835\n", - " 7156\n", - " AAK1\n", - " AAK1\n", - " 0.059276\n", - " 0.991333\n", - " 0.059276\n", - " in\n", - " in\n", + " mean\n", + " 1.518736e-01\n", + " 1.489599e-01\n", + " 0.137750\n", + " 1.607469e-01\n", " \n", " \n", - " 2\n", - " 3835\n", - " 1104\n", - " AAK1\n", - " ABL1\n", - " 0.275259\n", - " 0.990667\n", - " 0.275259\n", - " in\n", - " out-like\n", + " std\n", + " 5.115106e-02\n", + " 5.185786e-02\n", + " 0.055707\n", + " 4.802140e-02\n", " \n", " \n", - " 3\n", - " 3835\n", - " 1065\n", - " AAK1\n", - " ABL1\n", - " 0.284854\n", - " 0.990667\n", - " 0.284854\n", - " in\n", - " out\n", + " min\n", + " 0.000000e+00\n", + " 0.000000e+00\n", + " 0.000000\n", + " 1.784707e-02\n", " \n", " \n", - " 4\n", - " 3835\n", - " 1090\n", - " AAK1\n", - " ABL1\n", - " 0.262851\n", - " 0.990667\n", - " 0.262851\n", - " in\n", - " in\n", + " 25%\n", + " 1.166886e-01\n", + " 1.121125e-01\n", + " 0.104420\n", + " 1.280648e-01\n", + " \n", + " \n", + " 50%\n", + " 1.466822e-01\n", + " 1.444314e-01\n", + " 0.125542\n", + " 1.517770e-01\n", + " \n", + " \n", + " 75%\n", + " 1.793193e-01\n", + " 1.780976e-01\n", + " 0.159610\n", + " 1.822587e-01\n", + " \n", + " \n", + " max\n", + " 5.353785e-01\n", + " 5.353785e-01\n", + " 0.422093\n", + " 4.958527e-01\n", " \n", " \n", "\n", "" ], "text/plain": [ - " structure.1 structure.2 kinase.1 kinase.2 distance bit_coverage \\\n", - "0 3835 6679 AAK1 AAK1 0.051608 0.992667 \n", - "1 3835 7156 AAK1 AAK1 0.059276 0.991333 \n", - "2 3835 1104 AAK1 ABL1 0.275259 0.990667 \n", - "3 3835 1065 AAK1 ABL1 0.284854 0.990667 \n", - "4 3835 1090 AAK1 ABL1 0.262851 0.990667 \n", - "\n", - " distance_filtered dfg.1 dfg.2 \n", - "0 0.051608 in in \n", - "1 0.059276 in in \n", - "2 0.275259 in out-like \n", - "3 0.284854 in out \n", - "4 0.262851 in in " + " all in/in out/out in/out\n", + "count 1.173338e+07 8.674987e+06 99967.000000 1.865839e+06\n", + "mean 1.518736e-01 1.489599e-01 0.137750 1.607469e-01\n", + "std 5.115106e-02 5.185786e-02 0.055707 4.802140e-02\n", + "min 0.000000e+00 0.000000e+00 0.000000 1.784707e-02\n", + "25% 1.166886e-01 1.121125e-01 0.104420 1.280648e-01\n", + "50% 1.466822e-01 1.444314e-01 0.125542 1.517770e-01\n", + "75% 1.793193e-01 1.780976e-01 0.159610 1.822587e-01\n", + "max 5.353785e-01 5.353785e-01 0.422093 4.958527e-01" ] }, - "execution_count": 14, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "structure_distances.head()" + "plot_structure_distances_by_dfg_conformation_pairs(structure_distances)" ] }, { - "cell_type": "code", - "execution_count": 16, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "structure_distances_dfg = {\n", - " \"all\": structure_distances[\"distance_filtered\"],\n", - " \"in/in\": structure_distances[\n", - " (structure_distances[\"dfg.1\"] == \"in\") & (structure_distances[\"dfg.2\"] == \"in\")\n", - " ][\"distance_filtered\"],\n", - " \"out/out\": structure_distances[\n", - " (structure_distances[\"dfg.1\"] == \"out\") & (structure_distances[\"dfg.2\"] == \"out\")\n", - " ][\"distance_filtered\"],\n", - " \"in/out\": structure_distances[\n", - " ((structure_distances[\"dfg.1\"] == \"in\") & (structure_distances[\"dfg.2\"] == \"out\"))\n", - " | ((structure_distances[\"dfg.1\"] == \"out\") & (structure_distances[\"dfg.2\"] == \"in\"))\n", - " ][\"distance_filtered\"],\n", - "}\n", - "structure_distances_dfg = pd.DataFrame(structure_distances_dfg)" + "
\n", + "\n", + "When including all kinases at the same time, the distribution of fingerprint distances is similar for structure pairs with the same DFG conformations (in/in and out/out) and different DFG conformations (in/out). \n", + " \n", + "The fingerprint seems not to discriminate DFG-conformations on a kinome-wide level, maybe because the encoded spatial information is not restricted to only DFG conformation features. We may see a disciminative effect when comparing structures for a single kinase.\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Structures for one kinase\n", + "\n", + "Use fingerprint distances for structure pairs between the same kinase; use only kinases that have a sufficient number of structures in DFG-in and DFG-out conformations (default: 10). " ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def kinases_with_high_dfg_in_out_coverage(structure_distances, dfg_structure_coverage_cutoff=10):\n", + " \"\"\"Given a dataset, get kinases with a threshold DFG in/out coverage.\"\"\"\n", + "\n", + " # Get structure KLIFS IDs in our dataset\n", + " structure_klifs_ids = (\n", + " pd.concat(\n", + " [\n", + " structure_distances[\"structure.1\"].drop_duplicates(),\n", + " structure_distances[\"structure.2\"].drop_duplicates(),\n", + " ]\n", + " )\n", + " .drop_duplicates()\n", + " .to_list()\n", + " )\n", + " print(f\"Number of structures: {len(structure_klifs_ids)}\")\n", + "\n", + " # Get structural metadata\n", + " klifs_session = setup_remote()\n", + " structures = klifs_session.structures.all_structures()\n", + " structures = structures[structures[\"structure.klifs_id\"].isin(structure_klifs_ids)]\n", + "\n", + " # Count number of structures per kinase and conformation\n", + " dfg_by_kinase = structures.groupby(\"kinase.klifs_name\").apply(\n", + " lambda x: x[\"structure.dfg\"].value_counts()\n", + " )\n", + " dfg_by_kinase = dfg_by_kinase.reset_index()\n", + " dfg_by_kinase.columns = [\"kinase\", \"dfg\", \"n_structures\"]\n", + "\n", + " # Keep only in/out rows\n", + " dfg_by_kinase = dfg_by_kinase[(dfg_by_kinase[\"dfg\"] == \"in\") | (dfg_by_kinase[\"dfg\"] == \"out\")]\n", + "\n", + " # Keep only rows with at least xxx structures\n", + " dfg_by_kinase = dfg_by_kinase[dfg_by_kinase[\"n_structures\"] >= dfg_structure_coverage_cutoff]\n", + "\n", + " # Keep only kinases with both in/out conformations\n", + " n_conformations_by_kinase = dfg_by_kinase.groupby(\"kinase\").size()\n", + " dfg_by_kinase = dfg_by_kinase[\n", + " dfg_by_kinase[\"kinase\"].isin(\n", + " n_conformations_by_kinase[n_conformations_by_kinase == 2].index\n", + " )\n", + " ]\n", + "\n", + " return dfg_by_kinase.set_index([\"kinase\", \"dfg\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of structures: 4846\n" + ] + }, { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
n_structures
kinasedfg
BRAFin52
out29
EGFRin144
out10
EphA2in36
out17
METin49
out16
p38ain127
out74
\n", + "
" + ], "text/plain": [ - "all 11964546\n", - "in/in 8986558\n", - "out/out 80675\n", - "in/out 1706654\n", - "dtype: int64" + " n_structures\n", + "kinase dfg \n", + "BRAF in 52\n", + " out 29\n", + "EGFR in 144\n", + " out 10\n", + "EphA2 in 36\n", + " out 17\n", + "MET in 49\n", + " out 16\n", + "p38a in 127\n", + " out 74" ] }, - "execution_count": 17, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "structure_distances_dfg.notna().sum()" + "dfg_by_kinase = kinases_with_high_dfg_in_out_coverage(\n", + " structure_distances, dfg_structure_coverage_cutoff=10\n", + ")\n", + "dfg_by_kinase" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 13, "metadata": {}, "outputs": [ + { + "data": { + "text/markdown": [ + "#### BRAF" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of DFG-in structures: 52\n", + "Number of DFG-out structures: 29\n", + "Percentage of DFG-in: 64.2%\n", + "Number of structure pairs per conformation pair:\n", + "all 3240\n", + "in/in 1326\n", + "out/out 406\n", + "in/out 1508\n", + "dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { "text/html": [ @@ -682,103 +840,668 @@ " \n", " \n", " count\n", - " 1.196455e+07\n", - " 8.986558e+06\n", - " 80675.000000\n", - " 1.706654e+06\n", + " 3240.000000\n", + " 1326.000000\n", + " 406.000000\n", + " 1508.000000\n", " \n", " \n", " mean\n", - " 2.591149e-01\n", - " 2.568413e-01\n", - " 0.233366\n", - " 2.609551e-01\n", + " 0.114400\n", + " 0.102131\n", + " 0.069350\n", + " 0.137317\n", " \n", " \n", " std\n", - " 6.416281e-02\n", - " 6.517848e-02\n", - " 0.065284\n", - " 5.454680e-02\n", + " 0.041485\n", + " 0.039575\n", + " 0.031290\n", + " 0.029225\n", " \n", " \n", " min\n", - " 0.000000e+00\n", - " 0.000000e+00\n", - " 0.000000\n", - " 1.266475e-02\n", + " 0.006776\n", + " 0.006776\n", + " 0.017509\n", + " 0.062493\n", " \n", " \n", " 25%\n", - " 2.246006e-01\n", - " 2.223800e-01\n", - " 0.199945\n", - " 2.305254e-01\n", + " 0.088342\n", + " 0.081921\n", + " 0.040331\n", + " 0.119979\n", " \n", " \n", " 50%\n", - " 2.509275e-01\n", - " 2.486435e-01\n", - " 0.238215\n", - " 2.545010e-01\n", + " 0.119931\n", + " 0.105342\n", + " 0.063570\n", + " 0.135387\n", " \n", " \n", " 75%\n", - " 2.833567e-01\n", - " 2.811818e-01\n", - " 0.267869\n", - " 2.831307e-01\n", + " 0.145842\n", + " 0.137047\n", + " 0.097643\n", + " 0.163447\n", " \n", " \n", " max\n", - " 6.492761e-01\n", - " 6.359691e-01\n", - " 0.513118\n", - " 6.446349e-01\n", + " 0.195835\n", + " 0.171465\n", + " 0.139937\n", + " 0.195835\n", " \n", " \n", "\n", "" ], "text/plain": [ - " all in/in out/out in/out\n", - "count 1.196455e+07 8.986558e+06 80675.000000 1.706654e+06\n", - "mean 2.591149e-01 2.568413e-01 0.233366 2.609551e-01\n", - "std 6.416281e-02 6.517848e-02 0.065284 5.454680e-02\n", - "min 0.000000e+00 0.000000e+00 0.000000 1.266475e-02\n", - "25% 2.246006e-01 2.223800e-01 0.199945 2.305254e-01\n", - "50% 2.509275e-01 2.486435e-01 0.238215 2.545010e-01\n", - "75% 2.833567e-01 2.811818e-01 0.267869 2.831307e-01\n", - "max 6.492761e-01 6.359691e-01 0.513118 6.446349e-01" + " all in/in out/out in/out\n", + "count 3240.000000 1326.000000 406.000000 1508.000000\n", + "mean 0.114400 0.102131 0.069350 0.137317\n", + "std 0.041485 0.039575 0.031290 0.029225\n", + "min 0.006776 0.006776 0.017509 0.062493\n", + "25% 0.088342 0.081921 0.040331 0.119979\n", + "50% 0.119931 0.105342 0.063570 0.135387\n", + "75% 0.145842 0.137047 0.097643 0.163447\n", + "max 0.195835 0.171465 0.139937 0.195835" ] }, - "execution_count": 18, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "structure_distances_dfg.describe()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### EGFR" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of DFG-in structures: 144\n", + "Number of DFG-out structures: 10\n", + "Percentage of DFG-in: 93.51%\n", + "Number of structure pairs per conformation pair:\n", + "all 12720\n", + "in/in 10296\n", + "out/out 45\n", + "in/out 1440\n", + "dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
allin/inout/outin/out
count12720.00000010296.00000045.0000001440.000000
mean0.1128970.1056050.0689890.142613
std0.0540630.0545320.0451260.040115
min0.0060900.0060900.0067810.048179
25%0.0597800.0544210.0233940.097384
50%0.1173160.0892390.0512040.155302
75%0.1629000.1596690.1151180.176492
max0.2537720.2421650.1258300.253772
\n", + "
" + ], + "text/plain": [ + " all in/in out/out in/out\n", + "count 12720.000000 10296.000000 45.000000 1440.000000\n", + "mean 0.112897 0.105605 0.068989 0.142613\n", + "std 0.054063 0.054532 0.045126 0.040115\n", + "min 0.006090 0.006090 0.006781 0.048179\n", + "25% 0.059780 0.054421 0.023394 0.097384\n", + "50% 0.117316 0.089239 0.051204 0.155302\n", + "75% 0.162900 0.159669 0.115118 0.176492\n", + "max 0.253772 0.242165 0.125830 0.253772" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### EphA2" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of DFG-in structures: 36\n", + "Number of DFG-out structures: 17\n", + "Percentage of DFG-in: 67.92%\n", + "Number of structure pairs per conformation pair:\n", + "all 1378\n", + "in/in 630\n", + "out/out 136\n", + "in/out 612\n", + "dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
allin/inout/outin/out
count1378.000000630.000000136.000000612.000000
mean0.0817090.0633460.0422260.109387
std0.0395270.0373890.0326500.019606
min0.0051650.0051650.0063540.057455
25%0.0463060.0374730.0191070.097730
50%0.0934500.0546970.0267150.108559
75%0.1097440.0932130.0464660.117293
max0.1960330.1632640.1090370.196033
\n", + "
" + ], + "text/plain": [ + " all in/in out/out in/out\n", + "count 1378.000000 630.000000 136.000000 612.000000\n", + "mean 0.081709 0.063346 0.042226 0.109387\n", + "std 0.039527 0.037389 0.032650 0.019606\n", + "min 0.005165 0.005165 0.006354 0.057455\n", + "25% 0.046306 0.037473 0.019107 0.097730\n", + "50% 0.093450 0.054697 0.026715 0.108559\n", + "75% 0.109744 0.093213 0.046466 0.117293\n", + "max 0.196033 0.163264 0.109037 0.196033" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { - "image/png": "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\n", + "text/markdown": [ + "#### MET" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of DFG-in structures: 49\n", + "Number of DFG-out structures: 16\n", + "Percentage of DFG-in: 75.38%\n", + "Number of structure pairs per conformation pair:\n", + "all 2211\n", + "in/in 1176\n", + "out/out 120\n", + "in/out 784\n", + "dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
allin/inout/outin/out
count2211.0000001176.000000120.000000784.000000
mean0.1073080.0863360.0921820.140695
std0.0503390.0527610.0519390.023963
min0.0067910.0067910.0152070.059057
25%0.0691740.0424460.0590700.124800
50%0.1105590.0733950.0736240.140042
75%0.1472060.1125010.1100350.156143
max0.2521150.2294560.2237480.252115
\n", + "
" + ], + "text/plain": [ + " all in/in out/out in/out\n", + "count 2211.000000 1176.000000 120.000000 784.000000\n", + "mean 0.107308 0.086336 0.092182 0.140695\n", + "std 0.050339 0.052761 0.051939 0.023963\n", + "min 0.006791 0.006791 0.015207 0.059057\n", + "25% 0.069174 0.042446 0.059070 0.124800\n", + "50% 0.110559 0.073395 0.073624 0.140042\n", + "75% 0.147206 0.112501 0.110035 0.156143\n", + "max 0.252115 0.229456 0.223748 0.252115" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "#### p38a" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of DFG-in structures: 127\n", + "Number of DFG-out structures: 74\n", + "Percentage of DFG-in: 63.18%\n", + "Number of structure pairs per conformation pair:\n", + "all 28920\n", + "in/in 8001\n", + "out/out 2701\n", + "in/out 9398\n", + "dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
allin/inout/outin/out
count28920.0000008001.0000002701.0000009398.000000
mean0.1044780.0918170.0865380.115213
std0.0364590.0328080.0324750.032484
min0.0000000.0111520.0000000.028474
25%0.0765980.0664300.0639840.089868
50%0.1019660.0898290.0819290.111808
75%0.1297600.1149760.1079620.141183
max0.2634830.2407570.2001640.252040
\n", + "
" + ], + "text/plain": [ + " all in/in out/out in/out\n", + "count 28920.000000 8001.000000 2701.000000 9398.000000\n", + "mean 0.104478 0.091817 0.086538 0.115213\n", + "std 0.036459 0.032808 0.032475 0.032484\n", + "min 0.000000 0.011152 0.000000 0.028474\n", + "25% 0.076598 0.066430 0.063984 0.089868\n", + "50% 0.101966 0.089829 0.081929 0.111808\n", + "75% 0.129760 0.114976 0.107962 0.141183\n", + "max 0.263483 0.240757 0.200164 0.252040" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "structure_distances_dfg.plot(kind=\"box\", title=\"Conformation dependent structure pair distances\");" + "for kinase, dfg in dfg_by_kinase.reset_index().groupby(\"kinase\"):\n", + " display(Markdown(f\"#### {kinase}\"))\n", + " dfg = dfg.set_index(\"dfg\")\n", + " n_dfg_in = dfg.loc[\"in\", \"n_structures\"]\n", + " n_dfg_out = dfg.loc[\"out\", \"n_structures\"]\n", + " print(f\"Number of DFG-in structures: {n_dfg_in}\")\n", + " print(f\"Number of DFG-out structures: {n_dfg_out}\")\n", + " dfg_in_percentage = round(n_dfg_in / (n_dfg_in + n_dfg_out) * 100, 2)\n", + " print(f\"Percentage of DFG-in: {dfg_in_percentage}%\")\n", + " structure_distances_by_kinase = structure_distances[\n", + " (structure_distances[\"kinase.1\"] == kinase) & (structure_distances[\"kinase.2\"] == kinase)\n", + " ].reset_index(drop=True)\n", + " plot_structure_distances_by_dfg_conformation_pairs(structure_distances_by_kinase)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + "We compare here only fingerprint distances for pairs of structures that describe the same kinase. We observe two interesting shifts:\n", + " \n", + "1. The distribution for out/out pairs is overall lower than for in/in pairs. Potential explanations: definitions for DFG-out are stricter than for DFG-in; \"real\" diversity of DFG-out structures could be still unknown due to the lower number of structures for DFG-out than for DFG-in. \n", + "2. The distribution of different DFG conformations (in/out) is overall higher than for equal DFG conformations (in/in and out/out). The fingerprint can discriminate DFG conformations of the same kinase.\n", + "\n", + "
" ] } ], @@ -798,7 +1521,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.9.5" } }, "nbformat": 4, diff --git a/src/definitions.py b/src/definitions.py new file mode 100644 index 0000000..56a4815 --- /dev/null +++ b/src/definitions.py @@ -0,0 +1,5 @@ +""" +Defines globals. +""" + +COVERAGE_CUTOFF = 0.8 \ No newline at end of file diff --git a/src/evaluation/__init__.py b/src/evaluation/__init__.py index f0219d9..4b28c48 100644 --- a/src/evaluation/__init__.py +++ b/src/evaluation/__init__.py @@ -1 +1 @@ -from .ligand_vs_kinase_evaluator import LigandVsKinaseEvaluator # noqa: F401 +from .ligand_vs_kinase_evaluator import LigandVsKinaseEvaluator # noqa: F401 \ No newline at end of file