diff --git a/docs/tutorials/hfqueryapi_correlation_analysis_tutorial.ipynb b/docs/tutorials/hfqueryapi_correlation_analysis_tutorial.ipynb new file mode 100644 index 0000000..6535151 --- /dev/null +++ b/docs/tutorials/hfqueryapi_correlation_analysis_tutorial.ipynb @@ -0,0 +1,1533 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "275f5318", + "metadata": {}, + "source": [ + "# Mahendrawada 2025 vs Harbison 2004 Correlation Analysis Tutorial\n", + "\n", + "This tutorial demonstrates the steps to preprocess data and perform comprehensive correlation analysis between the Mahendrawada and Harbison datasets, while focusing on target distribution.\n", + "\n", + "## Overview\n", + "\n", + "Correlation analysis evalute the relationship between the two datasets by ensuring data integrity through filtering and examining correlations across p-values and effects, both globally and at the individual regulator level.\n", + "\n", + "### Datasets Used\n", + "- **Binding data**: Mahendrawada 2025 (binding), Harbison 2004 (binding)\n", + "\n", + "### Analysis Strategy\n", + "1. Load and filter out missing rows from both Mahendrawada and Harbison datasets\n", + "2. Plot the distribution of the number of common targets over regulators\n", + "3. Perform comprehensive correlation analysis across five key dimensions:\n", + " - overall p-value correlation\n", + " - overall effect correlation\n", + " - p-value correlation grouped by regulator\n", + " - effect correlation grouped by regulator\n", + " - p-value vs. effect correlation grouped by regulator" + ] + }, + { + "cell_type": "markdown", + "id": "88aaa29e", + "metadata": {}, + "source": [ + "# Initialize API and Check Available Configurations" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "a9af8a6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized HfQueryAPI for BrentLab/mahendrawada_2025\n", + "Repository type: dataset\n", + "Available configurations: ['genomic_features', 'mahendrawada_2025_metadata', 'chec_seq_genome_map', 'mahendrawada_chec_seq', 'reprocessed_chec_seq', 'reprocessed_diffcontrol_5prime', 'rna_seq']\n" + ] + } + ], + "source": [ + "from tfbpapi.HfQueryAPI import HfQueryAPI\n", + "import pandas as pd\n", + "\n", + "# Initialize the API client\n", + "mahendrawada_api = HfQueryAPI(repo_id=\"BrentLab/mahendrawada_2025\", repo_type=\"dataset\")\n", + "\n", + "print(f\"Initialized HfQueryAPI for {mahendrawada_api.repo_id}\")\n", + "print(f\"Repository type: {mahendrawada_api.repo_type}\")\n", + "print(f\"Available configurations: {[c.config_name for c in mahendrawada_api.configs]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "e60a7c86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized HfQueryAPI for BrentLab/harbison_2004\n", + "Repository type: dataset\n", + "Available configurations: ['harbison_2004']\n" + ] + } + ], + "source": [ + "# Initialize the API client\n", + "harbison_api = HfQueryAPI(repo_id=\"BrentLab/harbison_2004\", repo_type=\"dataset\")\n", + "\n", + "print(f\"Initialized HfQueryAPI for {harbison_api.repo_id}\")\n", + "print(f\"Repository type: {harbison_api.repo_type}\")\n", + "print(f\"Available configurations: {[c.config_name for c in harbison_api.configs]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "366298ff", + "metadata": {}, + "source": [ + "# Retrieve metadata for mahendrawada_2025 and check for duplicate values." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "284d697b", + "metadata": {}, + "outputs": [], + "source": [ + "mahendrawada_metadata = mahendrawada_api.get_metadata(\"reprocessed_diffcontrol_5prime\")" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "82811417", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " control_source condition regulator_locus_tag count\n", + "0 h2021 standard YNL027W 6708\n", + "1 m2025 standard YDL080C 6708\n", + "2 h2021 standard YLR223C 6708\n", + "3 h2021 raffinose YPL248C 6708\n", + "4 h2021 standard YNL199C 6708\n", + ".. ... ... ... ...\n", + "389 h2021 standard YBL103C 6708\n", + "390 m2025 standard YPL202C 6708\n", + "391 m2025 standard YOR038C 6708\n", + "392 m2025 standard YER111C 6708\n", + "393 h2021 standard YNL216W 6708\n", + "\n", + "[394 rows x 4 columns]\n" + ] + } + ], + "source": [ + "print(mahendrawada_metadata)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "2fbaa7c4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "control_source condition\n", + "h2021 30 2\n", + " 37 2\n", + " SM 1\n", + " WT 1\n", + " WT_SM 1\n", + " admut 1\n", + " admut_SM 1\n", + " cAD 1\n", + " cAD_SM 1\n", + " dbdmut 1\n", + " dbdmut_SM 1\n", + " galactose 1\n", + " nAD 1\n", + " nAD_SM 1\n", + " ncAD 1\n", + " ncAD_SM 1\n", + " raffinose 1\n", + " standard 178\n", + "m2025 30 2\n", + " 37 2\n", + " SM 1\n", + " WT 1\n", + " WT_SM 1\n", + " admut 1\n", + " admut_SM 1\n", + " cAD 1\n", + " cAD_SM 1\n", + " dbdmut 1\n", + " dbdmut_SM 1\n", + " galactose 1\n", + " nAD 1\n", + " nAD_SM 1\n", + " ncAD 1\n", + " ncAD_SM 1\n", + " raffinose 1\n", + " standard 178\n", + "dtype: int64" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mahendrawada_metadata.groupby([\"control_source\", \"condition\"]).size()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "4ede2a7c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Under control_source=h2021, condition=standard, regulator_locus_tag has no duplicate values.\n", + "Under control_source=m2025, condition=standard, regulator_locus_tag has no duplicate values.\n" + ] + } + ], + "source": [ + "# check h2021 - standard\n", + "h2021_standard = mahendrawada_metadata[(mahendrawada_metadata[\"control_source\"] == \"h2021\") & (mahendrawada_metadata[\"condition\"] == \"standard\")]\n", + "h2021_duplicates = h2021_standard[h2021_standard.duplicated(subset=[\"regulator_locus_tag\"], keep=False)]\n", + "if not h2021_duplicates.empty:\n", + " print(\"There are duplicate regulator_locus_tags under control_source=h2021, condition=standard:\")\n", + " print(h2021_duplicates[[\"regulator_locus_tag\"]])\n", + "else:\n", + " print(\"Under control_source=h2021, condition=standard, regulator_locus_tag has no duplicate values.\")\n", + "\n", + "# check m2025 - standard\n", + "m2025_standard = mahendrawada_metadata[(mahendrawada_metadata[\"control_source\"] == \"m2025\") & (mahendrawada_metadata[\"condition\"] == \"standard\")]\n", + "m2025_duplicates = m2025_standard[m2025_standard.duplicated(subset=[\"regulator_locus_tag\"], keep=False)]\n", + "if not m2025_duplicates.empty:\n", + " print(\"There are duplicate regulator_locus_tags under control_source=m2025, condition=standard:\")\n", + " print(m2025_duplicates[[\"regulator_locus_tag\"]])\n", + "else:\n", + " print(\"Under control_source=m2025, condition=standard, regulator_locus_tag has no duplicate values.\")" + ] + }, + { + "cell_type": "markdown", + "id": "bee118f5", + "metadata": {}, + "source": [ + "# Retrieve metadata for harbison_2004 and check for duplicate values." + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "59c1716b", + "metadata": {}, + "outputs": [], + "source": [ + "harbison__metadata = harbison_api.get_metadata(\"harbison_2004\")" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "30650fa4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " regulator_locus_tag regulator_symbol condition count\n", + "0 YER040W GLN3 YPD 6226\n", + "1 YPL202C AFT2 YPD 6226\n", + "2 YDR043C NRG1 H2O2Hi 6226\n", + "3 YOR028C CIN5 H2O2Lo 6226\n", + "4 YNL068C FKH2 H2O2Lo 6226\n", + ".. ... ... ... ...\n", + "347 YML076C WAR1 YPD 6226\n", + "348 YGL254W FZF1 YPD 6226\n", + "349 YMR070W MOT3 H2O2Lo 6226\n", + "350 YML007W YAP1 YPD 6226\n", + "351 YOR344C TYE7 YPD 6226\n", + "\n", + "[352 rows x 4 columns]\n" + ] + } + ], + "source": [ + "print(harbison__metadata)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "9a91d989", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "condition\n", + "Acid 2\n", + "Alpha 5\n", + "BUT14 8\n", + "BUT90 4\n", + "GAL 4\n", + "H2O2Hi 39\n", + "H2O2Lo 28\n", + "HEAT 6\n", + "Pi- 2\n", + "RAFF 1\n", + "RAPA 14\n", + "SM 34\n", + "Thi- 1\n", + "YPD 204\n", + "dtype: int64" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "harbison__metadata.groupby([\"condition\"]).size()" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "ca6cee5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Under condition=YPD, regulator_locus_tag has no duplicate values.\n" + ] + } + ], + "source": [ + "# When the check condition is YPD, check if the regulator_locus_tag is duplicated.\n", + "harbison_ypd = harbison__metadata[harbison__metadata[\"condition\"] == \"YPD\"]\n", + "harbison_ypd_duplicates = harbison_ypd[harbison_ypd.duplicated(subset=[\"regulator_locus_tag\"], keep=False)]\n", + "if not harbison_ypd_duplicates.empty:\n", + " print(\"There are duplicate regulator_locus_tags under condition=YPD:\")\n", + " print(harbison_ypd_duplicates[[\"regulator_locus_tag\"]])\n", + "else:\n", + " print(\"Under condition=YPD, regulator_locus_tag has no duplicate values.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "fc90c347", + "metadata": {}, + "source": [ + "# Check how many intersections there are between h2021 and m2025 of mahendrawada_2025 and harbison_2004." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "9bd17691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The intersection of harbison_ypd and the regulator_locus_tag of metadata[control_source='h2021', condition='standard']:\n", + "{'YMR164C', 'YIR023W', 'YGL131C', 'YDR463W', 'YBR239C', 'YDR421W', 'YML051W', 'YJL206C', 'YKR064W', 'YNL199C', 'YHR006W', 'YKR099W', 'YNL216W', 'YOR380W', 'YNL103W', 'YPL202C', 'YMR016C', 'YIL131C', 'YML076C', 'YEL009C', 'YDR213W', 'YBL005W', 'YGL209W', 'YBL103C', 'YOR162C', 'YOR229W', 'YBR049C', 'YKL015W', 'YNL167C', 'YER045C', 'YOR363C', 'YHR178W', 'YGL254W', 'YOR113W', 'YLR451W', 'YOL108C', 'YDR207C', 'YOR358W', 'YDR216W', 'YDL056W', 'YIR018W', 'YIL036W', 'YGL237C', 'YGL162W', 'YFR034C', 'YPL248C', 'YPL038W', 'YGL073W', 'YLR182W', 'YOL089C', 'YML007W', 'YGR249W', 'YER130C', 'YLR098C', 'YMR021C', 'YKL222C', 'YLR403W', 'YER169W', 'YML081W', 'YMR070W', 'YPL049C', 'YDR043C', 'YGL013C', 'YPR104C', 'YPL177C', 'YKL062W', 'YJR140C', 'YOR140W', 'YKL109W', 'YER111C', 'YFL021W', 'YLR014C', 'YPR022C', 'YDR253C', 'YMR037C', 'YNL068C', 'YHR206W', 'YJL110C', 'YBR182C', 'YDR451C', 'YDR423C', 'YJL056C', 'YNL027W', 'YLR176C', 'YGL035C', 'YMR042W', 'YDR310C', 'YDR123C', 'YDL106C', 'YER040W', 'YPR065W', 'YOR038C', 'YDR259C', 'YOL028C', 'YDL170W', 'YOR372C', 'YGR044C', 'YJR060W', 'YPR199C', 'YOR344C', 'YGR288W', 'YKL043W', 'YHR084W', 'YDR146C', 'YDR520C', 'YKL112W', 'YHL020C', 'YJR147W', 'YML027W', 'YKR034W', 'YPL089C', 'YGL096W', 'YNR063W', 'YNL309W', 'YDR081C', 'YNL314W', 'YBL021C', 'YFL031W', 'YKL032C', 'YMR043W', 'YIL101C', 'YHL027W', 'YLR223C', 'YMR182C', 'YDL048C', 'YPR009W', 'YBR083W', 'YOL067C', 'YLR228C', 'YPR008W', 'YPL230W'}\n", + "There are a total of 131 intersection elements.\n", + "The intersection of harbison_ypd and the regulator_locus_tag of metadata[control_source='m2025', condition='standard']:\n", + "{'YMR164C', 'YDR463W', 'YGL131C', 'YIR023W', 'YBR239C', 'YDR421W', 'YML051W', 'YJL206C', 'YKR064W', 'YNL199C', 'YHR006W', 'YKR099W', 'YNL216W', 'YOR380W', 'YNL103W', 'YPL202C', 'YIL131C', 'YMR016C', 'YML076C', 'YEL009C', 'YDR213W', 'YBL005W', 'YGL209W', 'YBL103C', 'YOR162C', 'YOR229W', 'YBR049C', 'YKL015W', 'YNL167C', 'YOR363C', 'YER045C', 'YHR178W', 'YGL254W', 'YOR113W', 'YLR451W', 'YOL108C', 'YDR207C', 'YOR358W', 'YDR216W', 'YDL056W', 'YIR018W', 'YIL036W', 'YGL237C', 'YFR034C', 'YGL162W', 'YPL248C', 'YGL073W', 'YPL038W', 'YLR182W', 'YOL089C', 'YML007W', 'YGR249W', 'YER130C', 'YLR098C', 'YMR021C', 'YKL222C', 'YLR403W', 'YER169W', 'YML081W', 'YMR070W', 'YPL049C', 'YDR043C', 'YGL013C', 'YPR104C', 'YPL177C', 'YKL062W', 'YJR140C', 'YOR140W', 'YKL109W', 'YER111C', 'YFL021W', 'YLR014C', 'YPR022C', 'YDR253C', 'YMR037C', 'YNL068C', 'YHR206W', 'YJL110C', 'YBR182C', 'YDR451C', 'YDR423C', 'YJL056C', 'YLR176C', 'YNL027W', 'YGL035C', 'YMR042W', 'YDR310C', 'YDR123C', 'YER040W', 'YDR259C', 'YOL028C', 'YPR065W', 'YDL106C', 'YOR038C', 'YDL170W', 'YGR044C', 'YOR372C', 'YJR060W', 'YPR199C', 'YOR344C', 'YGR288W', 'YHR084W', 'YKL043W', 'YDR146C', 'YDR520C', 'YKL112W', 'YHL020C', 'YJR147W', 'YML027W', 'YKR034W', 'YPL089C', 'YGL096W', 'YNR063W', 'YNL309W', 'YDR081C', 'YNL314W', 'YBL021C', 'YFL031W', 'YKL032C', 'YMR043W', 'YIL101C', 'YHL027W', 'YLR223C', 'YMR182C', 'YDL048C', 'YPR009W', 'YBR083W', 'YOL067C', 'YLR228C', 'YPR008W', 'YPL230W'}\n", + "There are a total of 131 intersection elements.\n" + ] + } + ], + "source": [ + "# Retrieve the regulator_locus_tag from harbison_ypd and remove duplicates.\n", + "harbison_ypd_tags = set(harbison_ypd[\"regulator_locus_tag\"].unique())\n", + "\n", + "# Retrieve the regulator_locus_tag with control_source=h2021 and condition=standard from the metadata and remove duplicates.\n", + "h2021_standard_tags = set(mahendrawada_metadata[(mahendrawada_metadata[\"control_source\"] == \"h2021\") & (mahendrawada_metadata[\"condition\"] == \"standard\")][\"regulator_locus_tag\"].unique())\n", + "\n", + "# Get the intersection\n", + "intersect_h2021 = harbison_ypd_tags & h2021_standard_tags\n", + "\n", + "# Output the intersection elements and number\n", + "print(\"The intersection of harbison_ypd and the regulator_locus_tag of metadata[control_source='h2021', condition='standard']:\")\n", + "print(intersect_h2021)\n", + "print(f\"There are a total of {len(intersect_h2021)} intersection elements.\")\n", + "\n", + "# Retrieve the regulator_locus_tag with control_source=m2025 and condition=standard from the metadata and remove duplicates.\n", + "m2025_standard_tags = set(mahendrawada_metadata[(mahendrawada_metadata[\"control_source\"] == \"m2025\") & (mahendrawada_metadata[\"condition\"] == \"standard\")][\"regulator_locus_tag\"].unique())\n", + "\n", + "# Get the intersection\n", + "intersect_m2025 = harbison_ypd_tags & m2025_standard_tags\n", + "\n", + "# Output the intersection elements and number\n", + "print(\"The intersection of harbison_ypd and the regulator_locus_tag of metadata[control_source='m2025', condition='standard']:\")\n", + "print(intersect_m2025)\n", + "print(f\"There are a total of {len(intersect_m2025)} intersection elements.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "743afcf2", + "metadata": {}, + "source": [ + "# Set filters and use the query function to retrieve data." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "50b05c2f", + "metadata": {}, + "outputs": [], + "source": [ + "# Set filters\n", + "harbison_api.set_filter(\"harbison_2004\", condition=\"YPD\")\n", + "mahendrawada_api.set_filter(\"reprocessed_diffcontrol_5prime\", condition=\"standard\")" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "729bbdfe", + "metadata": {}, + "outputs": [], + "source": [ + "harbison_YPD = harbison_api.query(\"SELECT * FROM harbison_2004 WHERE condition='YPD'\", \"harbison_2004\")\n", + "\n", + "h2021_standard = mahendrawada_api.query(\n", + " \"SELECT * FROM reprocessed_diffcontrol_5prime WHERE control_source='h2021'\",\n", + " \"reprocessed_diffcontrol_5prime\")\n", + " \n", + "m2025_standard = mahendrawada_api.query(\n", + " \"SELECT * FROM reprocessed_diffcontrol_5prime WHERE control_source='m2025'\",\n", + " \"reprocessed_diffcontrol_5prime\")" + ] + }, + { + "cell_type": "markdown", + "id": "dbc8e639", + "metadata": {}, + "source": [ + "Check if the effect has negative values." + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "eda7c297", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.014319528)" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "harbison_YPD.effect.min()" + ] + }, + { + "cell_type": "markdown", + "id": "a950ab92", + "metadata": {}, + "source": [ + "# Check both datasets and remove missing values" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "066fe1a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of missing values ​​in each column:\n", + " regulator_locus_tag 0\n", + "regulator_symbol 0\n", + "target_locus_tag 0\n", + "target_symbol 0\n", + "condition 0\n", + "effect 31732\n", + "pvalue 31682\n", + "dtype: int64\n", + "Percentage of missing values ​​in each column:\n", + " regulator_locus_tag 0.000000\n", + "regulator_symbol 0.000000\n", + "target_locus_tag 0.000000\n", + "target_symbol 0.000000\n", + "condition 0.000000\n", + "effect 0.024984\n", + "pvalue 0.024944\n", + "dtype: float64\n", + "Total number of missing values: 63414\n", + "Overall missing value ratio: 0.7133%\n" + ] + } + ], + "source": [ + "# Check if harbison_YPD has missing values ​​(NaN), and count the number and proportion.\n", + "import numpy as np\n", + "\n", + "# Count the number of missing values ​​in each column.\n", + "nan_counts = harbison_YPD.isna().sum()\n", + "print(\"Number of missing values ​​in each column:\\n\", nan_counts)\n", + "\n", + "# Count the proportion of missing values ​​in each column.\n", + "nan_ratios = harbison_YPD.isna().mean()\n", + "print(\"Percentage of missing values ​​in each column:\\n\", nan_ratios)\n", + "\n", + "# Count the total number of missing values ​​and the overall proportion.\n", + "total_nan = harbison_YPD.isna().sum().sum()\n", + "total_elements = np.prod(harbison_YPD.shape)\n", + "print(f\"Total number of missing values: {total_nan}\")\n", + "print(f\"Overall missing value ratio: {total_nan/total_elements:.4%}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "dc4f961f", + "metadata": {}, + "outputs": [], + "source": [ + "# Remove rows with missing values from harbison_YPD and store the result in a new variable (without changing harbison_YPD)\n", + "harbison_YPD_nonan = harbison_YPD.dropna()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "8346fc84", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NaN values in m2025_standard:\n", + " control_source 0\n", + "condition 0\n", + "regulator_locus_tag 0\n", + "target_locus_tag 0\n", + "chr 0\n", + "start 0\n", + "end 0\n", + "strand 0\n", + "input_vs_target_log2_fold_change 24429\n", + "input_vs_target_p_value 0\n", + "input_vs_target_adj_p_value 0\n", + "dtype: int64\n", + "NaN values in h2021_standard:\n", + " control_source 0\n", + "condition 0\n", + "regulator_locus_tag 0\n", + "target_locus_tag 0\n", + "chr 0\n", + "start 0\n", + "end 0\n", + "strand 0\n", + "input_vs_target_log2_fold_change 21443\n", + "input_vs_target_p_value 0\n", + "input_vs_target_adj_p_value 0\n", + "dtype: int64\n", + "m2025_standard missing rate:\n", + " control_source 0.000000\n", + "condition 0.000000\n", + "regulator_locus_tag 0.000000\n", + "target_locus_tag 0.000000\n", + "chr 0.000000\n", + "start 0.000000\n", + "end 0.000000\n", + "strand 0.000000\n", + "input_vs_target_log2_fold_change 0.020459\n", + "input_vs_target_p_value 0.000000\n", + "input_vs_target_adj_p_value 0.000000\n", + "dtype: float64\n", + "h2021_standard missing rate:\n", + " control_source 0.000000\n", + "condition 0.000000\n", + "regulator_locus_tag 0.000000\n", + "target_locus_tag 0.000000\n", + "chr 0.000000\n", + "start 0.000000\n", + "end 0.000000\n", + "strand 0.000000\n", + "input_vs_target_log2_fold_change 0.017959\n", + "input_vs_target_p_value 0.000000\n", + "input_vs_target_adj_p_value 0.000000\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "# Check if there are any NaN values in m2025_standard_masked and h2021_standard_masked\n", + "print(\"NaN values in m2025_standard:\\n\", m2025_standard.isna().sum())\n", + "print(\"NaN values in h2021_standard:\\n\", h2021_standard.isna().sum())\n", + "# calculate the data missing rate (NaN ratio)\n", + "nan_ratio_m2025 = m2025_standard.isna().mean()\n", + "nan_ratio_h2021 = h2021_standard.isna().mean()\n", + "print(\"m2025_standard missing rate:\\n\", nan_ratio_m2025)\n", + "print(\"h2021_standard missing rate:\\n\", nan_ratio_h2021)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "d00c6189", + "metadata": {}, + "outputs": [], + "source": [ + "# Remove missing values from m2025_standard and h2021_standard, and store in new variables\n", + "m2025_standard_nonan = m2025_standard.dropna()\n", + "h2021_standard_nonan = h2021_standard.dropna()" + ] + }, + { + "cell_type": "markdown", + "id": "e1b69ce3", + "metadata": {}, + "source": [ + "# Plot the distribution of the number of common targets over regulators" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "189737ac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Calculate the number of common targets for each regulator (regulator_locus_tag) in both datasets\n", + "\n", + "def get_common_targets_count(df1, df2):\n", + " # Group by regulator and store targets as sets\n", + " targets1 = df1.groupby(\"regulator_locus_tag\")[\"target_locus_tag\"].apply(set)\n", + " targets2 = df2.groupby(\"regulator_locus_tag\")[\"target_locus_tag\"].apply(set)\n", + " # Find regulators present in both datasets\n", + " common_regulators = set(targets1.index) & set(targets2.index)\n", + " # Calculate the number of common targets for each regulator\n", + " common_target_counts = []\n", + " for reg in common_regulators:\n", + " common_targets = targets1[reg] & targets2[reg]\n", + " common_target_counts.append(len(common_targets))\n", + " return common_target_counts\n", + "\n", + "# m2025_standard_nonan vs harbison_YPD_nonan\n", + "common_target_counts_m2025 = get_common_targets_count(m2025_standard_nonan, harbison_YPD_nonan)\n", + "\n", + "# h2021_standard_nonan vs harbison_YPD_nonan\n", + "common_target_counts_h2021 = get_common_targets_count(h2021_standard_nonan, harbison_YPD_nonan)\n", + "\n", + "# Plot the histograms to show the distribution of the number of common targets\n", + "plt.figure(figsize=(12,5))\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.hist(common_target_counts_m2025, bins=20, color='steelblue', edgecolor='k')\n", + "plt.title(\"m2025_standard_nonan vs harbison_YPD_nonan\\nCommon targets per regulator\")\n", + "plt.xlabel(\"Number of common targets\")\n", + "plt.ylabel(\"Number of regulators\")\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.hist(common_target_counts_h2021, bins=20, color='orange', edgecolor='k')\n", + "plt.title(\"h2021_standard_nonan vs harbison_YPD_nonan\\nCommon targets per regulator\")\n", + "plt.xlabel(\"Number of common targets\")\n", + "plt.ylabel(\"Number of regulators\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "ec8db020", + "metadata": {}, + "source": [ + "For the row with input_vs_target_log2_fold_change, we set input_vs_target_log2_fold_change to 0 and input_vs_target_adj_p_value to 1." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "46652151", + "metadata": {}, + "outputs": [], + "source": [ + "# harbison_h2021\n", + "mask_h2021 = h2021_standard_nonan[\"input_vs_target_log2_fold_change\"] < 0\n", + "h2021_standard_masked = h2021_standard_nonan.copy()\n", + "h2021_standard_masked.loc[mask_h2021, \"input_vs_target_adj_p_value\"] = 1\n", + "h2021_standard_masked.loc[mask_h2021, \"input_vs_target_log2_fold_change\"] = 0\n", + "\n", + "# harbison_m2025\n", + "mask_m2025 = m2025_standard_nonan[\"input_vs_target_log2_fold_change\"] < 0\n", + "m2025_standard_masked = m2025_standard_nonan.copy()\n", + "m2025_standard_masked.loc[mask_m2025, \"input_vs_target_adj_p_value\"] = 1\n", + "m2025_standard_masked.loc[mask_m2025, \"input_vs_target_log2_fold_change\"] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "a9d1fab1", + "metadata": {}, + "outputs": [], + "source": [ + "# Join harbison_YPD and h2021_standard based on the regulator_locus_tag field.\n", + "harbison_h2021_joined = harbison_YPD_nonan.merge(\n", + " h2021_standard_masked,\n", + " on=[\"regulator_locus_tag\", \"target_locus_tag\"],\n", + " suffixes=('_harbison', '_h2021')\n", + ")\n", + "\n", + "# Join harbison_YPD and m2025_standard based on the regulator_locus_tag field.\n", + "harbison_m2025_joined = harbison_YPD_nonan.merge(\n", + " m2025_standard_masked,\n", + " on=[\"regulator_locus_tag\", \"target_locus_tag\"],\n", + " suffixes=('_harbison', '_m2025')\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "761547b8", + "metadata": {}, + "outputs": [ + { + "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", + " \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", + " \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", + " \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", + "
regulator_locus_tagregulator_symboltarget_locus_tagtarget_symbolcondition_harbisoneffectpvaluecontrol_sourcecondition_m2025chrstartendstrandinput_vs_target_log2_fold_changeinput_vs_target_p_valueinput_vs_target_adj_p_value
0YKL112WABF1YAL001CTFC3YPD0.8601140.655859m2025standardchrI151169.0151868.0-0.0000002.155015e-061.000000
1YER045CACA1YAL001CTFC3YPD1.0205620.462418m2025standardchrI151169.0151868.0-0.0000008.366915e-021.000000
2YDR216WADR1YAL001CTFC3YPD1.3714790.062668m2025standardchrI151169.0151868.0-0.0000001.737008e-041.000000
3YPL202CAFT2YAL001CTFC3YPD1.0285800.470920m2025standardchrI151169.0151868.0-0.0000004.591905e-011.000000
4YMR042WARG80YAL001CTFC3YPD1.2128800.185439m2025standardchrI151169.0151868.0-0.0000002.036065e-081.000000
...................................................
787491YLR403WSFP1YPR204WYPR204WYPD1.0001190.500925m2025standardchrXVI944185.0944599.0+0.0000008.691729e-011.000000
787492YNL167CSKO1YPR204WYPR204WYPD1.1908530.285963m2025standardchrXVI944185.0944599.0+0.0000008.800214e-011.000000
787493YGL131CSNT2YPR204WYPR204WYPD0.8769570.755442m2025standardchrXVI944185.0944599.0+0.2171829.499403e-010.977196
787494YDR207CUME6YPR204WYPR204WYPD1.2851870.228696m2025standardchrXVI944185.0944599.0+0.0000005.004537e-011.000000
787495YOL028CYAP7YPR204WYPR204WYPD0.8894250.654632m2025standardchrXVI944185.0944599.0+0.0000007.562653e-011.000000
\n", + "

787496 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " regulator_locus_tag regulator_symbol target_locus_tag target_symbol \\\n", + "0 YKL112W ABF1 YAL001C TFC3 \n", + "1 YER045C ACA1 YAL001C TFC3 \n", + "2 YDR216W ADR1 YAL001C TFC3 \n", + "3 YPL202C AFT2 YAL001C TFC3 \n", + "4 YMR042W ARG80 YAL001C TFC3 \n", + "... ... ... ... ... \n", + "787491 YLR403W SFP1 YPR204W YPR204W \n", + "787492 YNL167C SKO1 YPR204W YPR204W \n", + "787493 YGL131C SNT2 YPR204W YPR204W \n", + "787494 YDR207C UME6 YPR204W YPR204W \n", + "787495 YOL028C YAP7 YPR204W YPR204W \n", + "\n", + " condition_harbison effect pvalue control_source condition_m2025 \\\n", + "0 YPD 0.860114 0.655859 m2025 standard \n", + "1 YPD 1.020562 0.462418 m2025 standard \n", + "2 YPD 1.371479 0.062668 m2025 standard \n", + "3 YPD 1.028580 0.470920 m2025 standard \n", + "4 YPD 1.212880 0.185439 m2025 standard \n", + "... ... ... ... ... ... \n", + "787491 YPD 1.000119 0.500925 m2025 standard \n", + "787492 YPD 1.190853 0.285963 m2025 standard \n", + "787493 YPD 0.876957 0.755442 m2025 standard \n", + "787494 YPD 1.285187 0.228696 m2025 standard \n", + "787495 YPD 0.889425 0.654632 m2025 standard \n", + "\n", + " chr start end strand input_vs_target_log2_fold_change \\\n", + "0 chrI 151169.0 151868.0 - 0.000000 \n", + "1 chrI 151169.0 151868.0 - 0.000000 \n", + "2 chrI 151169.0 151868.0 - 0.000000 \n", + "3 chrI 151169.0 151868.0 - 0.000000 \n", + "4 chrI 151169.0 151868.0 - 0.000000 \n", + "... ... ... ... ... ... \n", + "787491 chrXVI 944185.0 944599.0 + 0.000000 \n", + "787492 chrXVI 944185.0 944599.0 + 0.000000 \n", + "787493 chrXVI 944185.0 944599.0 + 0.217182 \n", + "787494 chrXVI 944185.0 944599.0 + 0.000000 \n", + "787495 chrXVI 944185.0 944599.0 + 0.000000 \n", + "\n", + " input_vs_target_p_value input_vs_target_adj_p_value \n", + "0 2.155015e-06 1.000000 \n", + "1 8.366915e-02 1.000000 \n", + "2 1.737008e-04 1.000000 \n", + "3 4.591905e-01 1.000000 \n", + "4 2.036065e-08 1.000000 \n", + "... ... ... \n", + "787491 8.691729e-01 1.000000 \n", + "787492 8.800214e-01 1.000000 \n", + "787493 9.499403e-01 0.977196 \n", + "787494 5.004537e-01 1.000000 \n", + "787495 7.562653e-01 1.000000 \n", + "\n", + "[787496 rows x 16 columns]" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "harbison_m2025_joined" + ] + }, + { + "cell_type": "markdown", + "id": "5a27c52c", + "metadata": {}, + "source": [ + "# Overall Analysis：P-value ranking correlation analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "dac35b74", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spearman rank correlation of regulators for harbison_2004 vs mahendrawada_2025 (h2021): -0.012, p-value: 5.8e-25\n", + "Spearman rank correlation of regulators for harbison_2004 vs mahendrawada_2025 (m2025): -0.026, p-value: 2.7e-116\n" + ] + } + ], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "# Calculate the Spearman rank correlation between harbison_2004 and mahendrawada_2025 (h2021 joined regulators)\n", + "df_h2021 = harbison_h2021_joined[[\"pvalue\", \"input_vs_target_adj_p_value\"]].dropna()\n", + "spearman_corr_h2021, spearman_p_h2021 = spearmanr(df_h2021[\"pvalue\"], df_h2021[\"input_vs_target_adj_p_value\"])\n", + "\n", + "print(\"Spearman rank correlation of regulators for harbison_2004 vs mahendrawada_2025 (h2021): {:.3f}, p-value: {:.2g}\".format(spearman_corr_h2021, spearman_p_h2021))\n", + "\n", + "# Calculate the Spearman rank correlation between harbison_2004 and mahendrawada_2025 (m2025 joined regulators)\n", + "df_m2025 = harbison_m2025_joined[[\"pvalue\", \"input_vs_target_adj_p_value\"]].dropna()\n", + "spearman_corr_m2025, spearman_p_m2025 = spearmanr(df_m2025[\"pvalue\"], df_m2025[\"input_vs_target_adj_p_value\"])\n", + "\n", + "print(\"Spearman rank correlation of regulators for harbison_2004 vs mahendrawada_2025 (m2025): {:.3f}, p-value: {:.2g}\".format(spearman_corr_m2025, spearman_p_m2025))\n" + ] + }, + { + "cell_type": "markdown", + "id": "cc62e782", + "metadata": {}, + "source": [ + "# Overall Analysis：effect correlation analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "ac8a4bc4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spearman correlation between 'effect' and 'input_vs_target_log2_fold_change' (h2021): 0.000, p-value: 0.94\n", + "Spearman correlation between 'effect' and 'input_vs_target_log2_fold_change' (m2025): -0.014, p-value: 5.2e-36\n" + ] + } + ], + "source": [ + "# Perform correlation analysis between 'effect' and 'input_vs_target_log2_fold_change' for both joined datasets.\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "# For harbison_h2021_joined\n", + "effect_h2021 = harbison_h2021_joined[[\"effect\", \"input_vs_target_log2_fold_change\"]].dropna()\n", + "corr_h2021, pval_h2021 = spearmanr(effect_h2021[\"effect\"], effect_h2021[\"input_vs_target_log2_fold_change\"])\n", + "print(\"Spearman correlation between 'effect' and 'input_vs_target_log2_fold_change' (h2021): {:.3f}, p-value: {:.2g}\".format(corr_h2021, pval_h2021))\n", + "\n", + "# For harbison_m2025_joined\n", + "effect_m2025 = harbison_m2025_joined[[\"effect\", \"input_vs_target_log2_fold_change\"]].dropna()\n", + "corr_m2025, pval_m2025 = spearmanr(effect_m2025[\"effect\"], effect_m2025[\"input_vs_target_log2_fold_change\"])\n", + "print(\"Spearman correlation between 'effect' and 'input_vs_target_log2_fold_change' (m2025): {:.3f}, p-value: {:.2g}\".format(corr_m2025, pval_m2025))\n" + ] + }, + { + "cell_type": "markdown", + "id": "16e20ec9", + "metadata": {}, + "source": [ + "# Group by regulators: P-value ranking correlation analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "551cb15b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Group by regulator_symbol, calculate the Spearman rank correlation between 'pvalue' (from harbison_2004) and 'input_vs_target_adj_p_value' (from mahendrawada_2025) for each regulator.\n", + "# Visualize the distribution of per-regulator Spearman correlations as separate plots for h2021 and m2025.\n", + "# When plotting, only include results for regulators where the correlation p-value is less than 0.05.\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from scipy.stats import spearmanr\n", + "\n", + "# Ensure regulator_symbol, pvalue, and input_vs_target_adj_p_value columns exist for h2021\n", + "assert 'regulator_symbol' in harbison_h2021_joined.columns\n", + "assert 'pvalue' in harbison_h2021_joined.columns\n", + "assert 'input_vs_target_adj_p_value' in harbison_h2021_joined.columns\n", + "\n", + "# Likewise, ensure required columns exist for m2025\n", + "assert 'regulator_symbol' in harbison_m2025_joined.columns\n", + "assert 'pvalue' in harbison_m2025_joined.columns\n", + "assert 'input_vs_target_adj_p_value' in harbison_m2025_joined.columns\n", + "\n", + "def groupwise_spearman(df, p_col, q_col, group_col='regulator_symbol', min_size=3, pval_threshold=0.05):\n", + " \"\"\"\n", + " Calculates per-group Spearman correlation and filters by minimum group size and p-value threshold.\n", + " \"\"\"\n", + " results = []\n", + " for reg, group in df.groupby(group_col):\n", + " g_clean = group[[p_col, q_col]].dropna()\n", + " if len(g_clean) >= min_size:\n", + " corr, pval = spearmanr(g_clean[p_col], g_clean[q_col])\n", + " if pd.notna(corr) and pd.notna(pval) and pval < pval_threshold:\n", + " results.append(\n", + " {\n", + " \"regulator\": reg,\n", + " \"spearman_corr\": corr,\n", + " \"spearman_pval\": pval,\n", + " \"n\": len(g_clean)\n", + " }\n", + " )\n", + " return pd.DataFrame(results)\n", + "\n", + "# For the h2021 dataset\n", + "h2021_corrs = groupwise_spearman(\n", + " harbison_h2021_joined,\n", + " \"pvalue\",\n", + " \"input_vs_target_adj_p_value\",\n", + " group_col=\"regulator_symbol\",\n", + " min_size=3,\n", + " pval_threshold=0.05\n", + ")\n", + "\n", + "# For the m2025 dataset\n", + "m2025_corrs = groupwise_spearman(\n", + " harbison_m2025_joined,\n", + " \"pvalue\",\n", + " \"input_vs_target_adj_p_value\",\n", + " group_col=\"regulator_symbol\",\n", + " min_size=3,\n", + " pval_threshold=0.05\n", + ")\n", + "\n", + "# Plot the distribution for h2021\n", + "plt.figure(figsize=(10, 5))\n", + "plt.hist(h2021_corrs['spearman_corr'].dropna(), bins=30, alpha=0.8, color='C0')\n", + "plt.xlabel(\"Spearman correlation per regulator (pvalue vs adj_p_value)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Spearman rank correlation distribution for each regulator (h2021, p<0.05)\")\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot the distribution for m2025\n", + "plt.figure(figsize=(10, 5))\n", + "plt.hist(m2025_corrs['spearman_corr'].dropna(), bins=30, alpha=0.8, color='C1')\n", + "plt.xlabel(\"Spearman correlation per regulator (pvalue vs adj_p_value)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Spearman rank correlation distribution for each regulator (m2025, p<0.05)\")\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "63fdcc4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regulators in h2021 with Spearman correlation > 0.4:\n", + "['INO4', 'RAP1']\n", + "\n", + "Regulators in m2025 (p<0.05) with Spearman correlation > 0.4:\n", + "['INO4', 'RAP1']\n" + ] + } + ], + "source": [ + "# Print the names of regulators with Spearman correlation greater than 0.4 (for h2021 and m2025, p<0.05)\n", + "\n", + "print(\"Regulators in h2021 with Spearman correlation > 0.4:\")\n", + "regulators_h2021 = h2021_corrs.loc[h2021_corrs['spearman_corr'] > 0.4, 'regulator']\n", + "print(regulators_h2021.tolist())\n", + "\n", + "print(\"\\nRegulators in m2025 (p<0.05) with Spearman correlation > 0.4:\")\n", + "regulators_m2025 = m2025_corrs.loc[m2025_corrs['spearman_corr'] > 0.4, 'regulator']\n", + "print(regulators_m2025.tolist())\n" + ] + }, + { + "cell_type": "markdown", + "id": "9d551927", + "metadata": {}, + "source": [ + "# Group by regulators: effect correlation analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "c8dbd7f2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Group by regulator_symbol, calculate the Spearman correlation between effect and input_vs_target_log2_fold_change\n", + "# Perform grouping and plotting for both h2021 and m2025 datasets\n", + "\n", + "from scipy.stats import spearmanr\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def groupwise_effect_corr(df, effect_col=\"effect\", logfc_col=\"input_vs_target_log2_fold_change\", group_col=\"regulator_symbol\", min_size=3):\n", + " # Calculate the Spearman correlation coefficient and p-value for each group\n", + " results = []\n", + " grouped = df[[group_col, effect_col, logfc_col]].dropna().groupby(group_col)\n", + " for name, grp in grouped:\n", + " if len(grp) >= min_size:\n", + " corr, pval = spearmanr(grp[effect_col], grp[logfc_col])\n", + " results.append({\n", + " group_col: name,\n", + " \"n\": len(grp),\n", + " \"spearman_corr\": corr,\n", + " \"pval\": pval\n", + " })\n", + " return pd.DataFrame(results)\n", + "\n", + "# Calculate correlations for h2021 dataset\n", + "h2021_effect_corrs = groupwise_effect_corr(harbison_h2021_joined)\n", + "\n", + "# Calculate correlations for m2025 dataset\n", + "m2025_effect_corrs = groupwise_effect_corr(harbison_m2025_joined)\n", + "\n", + "# Plot histogram for h2021\n", + "plt.figure(figsize=(10, 5))\n", + "plt.hist(h2021_effect_corrs['spearman_corr'].dropna(), bins=30, alpha=0.7, color='C2', label=\"h2021\")\n", + "plt.xlabel(\"Spearman correlation per regulator (effect vs log2FC)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Spearman rank correlation distribution for each regulator (h2021, effect vs log2FC)\")\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "# Plot histogram for m2025\n", + "plt.figure(figsize=(10, 5))\n", + "plt.hist(m2025_effect_corrs['spearman_corr'].dropna(), bins=30, alpha=0.7, color='C3', label=\"m2025\")\n", + "plt.xlabel(\"Spearman correlation per regulator (effect vs log2FC)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Spearman rank correlation distribution for each regulator (m2025, effect vs log2FC)\")\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "d81d6115", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regulators with Spearman correlation > 0.4 (h2021):\n", + "['INO4', 'RAP1']\n", + "Regulators with Spearman correlation > 0.4 (m2025):\n", + "['INO4', 'RAP1']\n" + ] + } + ], + "source": [ + "# Print regulators with Spearman correlation > 0.4 for h2021 and m2025\n", + "\n", + "# For h2021\n", + "high_corr_h2021 = h2021_effect_corrs[h2021_effect_corrs['spearman_corr'] > 0.4]\n", + "print(\"Regulators with Spearman correlation > 0.4 (h2021):\")\n", + "print(high_corr_h2021['regulator_symbol'].tolist())\n", + "\n", + "# For m2025\n", + "high_corr_m2025 = m2025_effect_corrs[m2025_effect_corrs['spearman_corr'] > 0.4]\n", + "print(\"Regulators with Spearman correlation > 0.4 (m2025):\")\n", + "print(high_corr_m2025['regulator_symbol'].tolist())\n" + ] + }, + { + "cell_type": "markdown", + "id": "a66d478c", + "metadata": {}, + "source": [ + "# Group by regulators: effect vs p-value correlation analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "682f1bcb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def groupwise_effect_pvalue_corr(df):\n", + " \"\"\"\n", + " For each regulator_symbol, compute Spearman's rank correlation between effect and -log10(p-value)\n", + " \"\"\"\n", + " from scipy.stats import spearmanr\n", + "\n", + " results = []\n", + " grouped = df.groupby('regulator_symbol')\n", + " for reg, group in grouped:\n", + " # Drop missing values\n", + " valid = group[['effect', 'input_vs_target_adj_p_value']].dropna()\n", + " if len(valid) < 2:\n", + " corr = np.nan\n", + " else:\n", + " # Use -log10(p-value) to emphasize stronger significance\n", + " neglog_p = -np.log10(valid['input_vs_target_adj_p_value'].replace(0, np.nan))\n", + " # Sometimes there might still be nans or infs after log transformation\n", + " mask = neglog_p.replace([np.inf, -np.inf], np.nan).notnull() & valid['effect'].notnull()\n", + " if mask.sum() < 2:\n", + " corr = np.nan\n", + " else:\n", + " corr, _ = spearmanr(valid['effect'][mask], neglog_p[mask])\n", + " results.append({\"regulator_symbol\": reg, \"spearman_corr\": corr, \"n\": len(valid)})\n", + " return pd.DataFrame(results)\n", + "\n", + "# Calculate groupwise effect vs -log10(adj p-value) correlation for h2021 and m2025\n", + "h2021_effect_p_corrs = groupwise_effect_pvalue_corr(harbison_h2021_joined)\n", + "m2025_effect_p_corrs = groupwise_effect_pvalue_corr(harbison_m2025_joined)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 5))\n", + "plt.hist(h2021_effect_p_corrs['spearman_corr'].dropna(), bins=30, alpha=0.7, color='C0')\n", + "plt.xlabel(\"Spearman correlation per regulator (effect vs -log10(adjusted p-value))\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Spearman correlation: effect vs -log10(adjusted p-value) (h2021)\")\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.hist(m2025_effect_p_corrs['spearman_corr'].dropna(), bins=30, alpha=0.7, color='C1')\n", + "plt.xlabel(\"Spearman correlation per regulator (effect vs -log10(adjusted p-value))\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Spearman correlation: effect vs -log10(adjusted p-value) (m2025)\")\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "19fc3d62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h2021 regulators with Spearman correlation > 0.4:\n", + "['INO4', 'RAP1']\n", + "\n", + "m2025 regulators with Spearman correlation > 0.4:\n", + "['INO4', 'RAP1']\n" + ] + } + ], + "source": [ + "print(\"h2021 regulators with Spearman correlation > 0.4:\")\n", + "print(h2021_effect_p_corrs[h2021_effect_p_corrs['spearman_corr'] > 0.4]['regulator_symbol'].tolist())\n", + "\n", + "print(\"\\nm2025 regulators with Spearman correlation > 0.4:\")\n", + "print(m2025_effect_p_corrs[m2025_effect_p_corrs['spearman_corr'] > 0.4]['regulator_symbol'].tolist())\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}