3C.[GO set]Evaluate_gene_set_similarity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook for analyze the gene set similarity with hypergeometric test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:06<00:00, 163.94it/s]\n"
     ]
    }
   ],
   "source": [
    "%run hypergeometric_GO.py --input_file data/GO_term_analysis/simrank_LLM_processed_selected_1000_go_terms.tsv --topn 3 --output_file data/GO_term_analysis/simrank_pval_LLM_processed_selected_1000_go_terms.tsv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import seaborn as sns\n",
    "from glob import glob\n",
    "import re\n",
    "from scipy.stats import wilcoxon, mannwhitneyu\n",
    "\n",
    "# Set default configuration for all plots\n",
    "plt.rcParams['svg.fonttype'] = 'none'\n",
    "plt.rcParams['pdf.fonttype'] = 42\n",
    "plt.rcParams.update({'font.size': 7, 'font.family': 'sans-serif'})\n",
    "plt.rcParams['xtick.labelsize'] = 6\n",
    "plt.rcParams['ytick.labelsize'] = 6\n",
    "plt.rcParams['axes.labelsize'] = 7\n",
    "plt.rcParams['axes.titlesize'] = 7\n",
    "plt.rcParams['axes.linewidth'] = 0.5\n",
    "plt.rcParams['hatch.linewidth'] = 0.5\n",
    "plt.rcParams['xtick.major.width'] = 0.4\n",
    "plt.rcParams['ytick.major.width'] = 0.4\n",
    "plt.rcParams['xtick.minor.width'] = 0.3\n",
    "plt.rcParams['ytick.minor.width'] = 0.3\n",
    "plt.rcParams['legend.frameon'] = False\n",
    "plt.rcParams['xtick.major.size'] = 3\n",
    "plt.rcParams['ytick.major.size'] = 3\n",
    "plt.rcParams['xtick.minor.size'] = 2\n",
    "plt.rcParams['ytick.minor.size'] = 2\n",
    "plt.rcParams['xtick.major.pad'] = 1\n",
    "plt.rcParams['ytick.major.pad'] = 1\n",
    "plt.rcParams['axes.labelpad'] = 1\n",
    "plt.rcParams['patch.linewidth'] = 0.25\n",
    "plt.rcParams[\"axes.unicode_minus\"] = True\n",
    "plt.figsize = (2,2)    \n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "df = pd.read_csv('data/GO_term_analysis/simrank_pval_LLM_processed_selected_1000_go_terms.tsv', sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['GO', 'Genes', 'Gene_Count', 'Term_Description', 'gpt_4_default Name',\n",
       "       'gpt_4_default Analysis', 'gpt_4_default Score',\n",
       "       'gpt_4_default Score Bin', 'LLM_name_GO_term_sim', 'sim_rank',\n",
       "       'true_GO_term_sim_percentile', 'random_GO_name', 'random_go_llm_sim',\n",
       "       'random_sim_rank', 'random_sim_percentile', 'top_3_hits', 'top_3_sim',\n",
       "       'pvals', 'adj_pvals', 'random_pvals', 'random_adj_pvals', 'JI',\n",
       "       'random JI'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def genes_coverage(genes, all_genes):\n",
    "    return len(set(genes).intersection(set(all_genes))) / len(genes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exact match:  33\n",
      "Match in top 3:  64\n"
     ]
    }
   ],
   "source": [
    "# number of terms that the best match term is the query term \n",
    "exact_match = 0\n",
    "match_in_top_3 = 0\n",
    "for i, row in df.iterrows():\n",
    "    if row['Term_Description'] in row['top_3_hits'].split('|'):\n",
    "        match_in_top_3 += 1\n",
    "        if row['Term_Description'] == row['top_3_hits'].split('|')[0]:\n",
    "            exact_match += 1\n",
    "print('Exact match: ', exact_match) \n",
    "print('Match in top 3: ', match_in_top_3)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## calculate the coverage of broader concept \n",
    "in the cases where GO names are not semantically similar GPT 4 name\n",
    "\n",
    "Calculate if the best matching name is associated to a term that is more general concept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(371, 24)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 371/371 [00:00<00:00, 1034.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "316 55\n",
      "Coverage >=50%: 131\n",
      "Overlap >=50%: 1\n",
      "Coverage >=50%: 35.309973045822105%\n",
      "Overlap >=50%: 0.2695417789757413%\n",
      "Coverage >=30%: 177\n",
      "Overlap >=30%: 3\n",
      "Coverage >=30%: 47.7088948787062%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import  pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def genes_coverage(genes, all_genes):\n",
    "    return len(set(genes).intersection(set(all_genes))) / len(genes)\n",
    "\n",
    "df = pd.read_csv('data/GO_term_analysis/simrank_pval_LLM_processed_selected_1000_go_terms.tsv', sep='\\t')\n",
    "df.set_index('GO', inplace=True)\n",
    "all_go = pd.read_csv('data/go_terms.csv', index_col=0)\n",
    "\n",
    "# filter the list by ranking the percentile and keep terms with true_GO_term_sim_percentile < 0.95\n",
    "\n",
    "df_sorted = df.sort_values(by='true_GO_term_sim_percentile', ascending=True)\n",
    "df_filtered = df_sorted[df_sorted['true_GO_term_sim_percentile'] < 0.95]\n",
    "\n",
    "# because System of unrelated proteins will not have a best name that covers>50% of the genes\n",
    "df_filtered = df_filtered[df_filtered['gpt_4_default Name']!= 'System of unrelated proteins']\n",
    "print(df_filtered.shape)\n",
    "new_df = df_filtered.loc[:,['Genes', 'Gene_Count', 'Term_Description','gpt_4_default Name',\n",
    "       'gpt_4_default Analysis', 'gpt_4_default Score','gpt_4_default Score Bin', 'LLM_name_GO_term_sim','top_3_hits']]\n",
    "\n",
    "new_df['covered_by_best_match'] = False\n",
    "\n",
    "genes_coverage_list = []\n",
    "genes_overlap_list = []\n",
    "for i, row in tqdm(new_df.iterrows(), total=new_df.shape[0]):\n",
    "    current_gene_set = row['Genes'].split(' ')\n",
    "    top_n_hits = row[f'top_3_hits'].split('|')\n",
    "    top_match = top_n_hits[0]\n",
    "    genes = all_go[all_go['Term_Description'] == top_match]['Genes'].tolist()[0].split(' ')\n",
    "    \n",
    "    if len(genes)>len(current_gene_set):\n",
    "        coverage = genes_coverage(current_gene_set, genes)\n",
    "        genes_coverage_list.append(coverage)\n",
    "    else:\n",
    "        coverage = genes_coverage(current_gene_set, genes)\n",
    "        genes_overlap_list.append(coverage)\n",
    "    new_df.loc[i, 'best_match_coverage'] = coverage\n",
    "    if coverage >= 0.5:\n",
    "        new_df.loc[i, 'covered_by_best_match'] = True\n",
    "        \n",
    "\n",
    "# check how many are giving a general term coverage >=50%, how many are giving a specific term coverage >=50%\n",
    "print(len(genes_coverage_list), len(genes_overlap_list))\n",
    "high_coverage = np.sum(np.array(genes_coverage_list)>=0.5)\n",
    "high_overlap = np.sum(np.array(genes_overlap_list)>=0.5)\n",
    "print(f'Coverage >=50%: {high_coverage}')\n",
    "print(f'Overlap >=50%: {high_overlap}')   \n",
    "print(f'Coverage >=50%: {(high_coverage/len(new_df))*100}%')\n",
    "print(f'Overlap >=50%: {(high_overlap/len(new_df))*100}%')\n",
    "\n",
    "print(f'Coverage >=30%: {np.sum(np.array(genes_coverage_list)>=0.3)}')\n",
    "print(f'Overlap >=30%: {np.sum(np.array(genes_overlap_list)>=0.3)}')\n",
    "print(f'Coverage >=30%: {(np.sum(np.array(genes_coverage_list)>=0.3)/len(new_df))*100}%')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Initialize lists to store the number of terms at each cutoff\n",
    "coverage_cutoffs = np.arange(0.1, 1.1, 0.1)\n",
    "covered_terms = []\n",
    "\n",
    "\n",
    "# Calculate how many terms have coverage above each cutoff\n",
    "for cutoff in coverage_cutoffs:\n",
    "    high_coverage = np.sum(np.array(genes_coverage_list) >= cutoff)\n",
    "    covered_terms.append(high_coverage)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(3, 3))\n",
    "plt.plot(coverage_cutoffs, covered_terms, marker='o', markersize=5)\n",
    "plt.xlabel('Coverage cutoff')\n",
    "plt.ylabel('Number of broader concepts')\n",
    "# plot vertical line at 0.5\n",
    "plt.axvline(x=0.5, color='r', linestyle='--')\n",
    "sns.despine()\n",
    "\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot a pie chart  \n",
    "### Figure 2d\n",
    "\n",
    "hits = sum(df_sorted['true_GO_term_sim_percentile'] >= 0.95)\n",
    "# high_coverage\n",
    "\n",
    "mismatches = len(df_sorted) - hits - high_coverage\n",
    "labels = ['High similarity', 'Mismatches', 'Matching a broarder concept']\n",
    "sizes = [hits, mismatches, high_coverage]\n",
    "colors = ['#3a5a40','#dad7cd','#a3b18a']\n",
    "fig, ax = plt.subplots(figsize=(3,3))\n",
    "ax.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90)\n",
    "fig.savefig('figures/GPT4_GO_compare_stats_pie_chart.svg', bbox_inches='tight')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAREAAAEJCAYAAACzERN4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAPdklEQVR4nO3df0yVdf/H8RcCJyJDIKgby3vNYqk1a2UWcPihTI9xT7aWhbqxWH+YZhYtN+/c0oRYtiar1ay2TNnczGgzV6DH1JEo9oMtDBUZut0udPPoQDg5kx9e3z/83qfbr99Qe190Lm6fj7+4zoXX5z31PL0O5yPEOI7jCAD+pFHRHgDAyEZEAJgQEQAmRASACREBYEJEAJgQEQAmRASASVQjsmjRomguD8AFUY3IiRMnork8ABfwcgaACREBYEJEAJgQEQAmRASAyXVFpKenR1OnTtXo0aN18OBBhcNhTZ8+XXl5eZo+fbqOHz8uSTpy5Ijy8vKUnZ2tXbt2DcvgALzhuiKSmJiouro6zZkzR5IUHx+vjRs3as+ePVq2bJneeecdSdLy5cu1bt06bd++XStWrHB/agCecV0RiY+PV3p6euQ4ISFBY8eOlST5fD6NGnXpcidPnlRmZqaSkpKUmpqqM2fOuDgyAC+Jc+MifX19euONN/TJJ59Iki5evBg5N2bMGHV1dSktLU3BYFDBYDByLhQKubE8gChyJSILFizQCy+8oMzMTEmK3JFIl76OkpqaKkkKBAIKBAKRc8XFxde8xt3/rHNj1Mv8a/U/XL8mcKMxvzuzatUqjR8/XiUlJZHHMjIydOzYMYXD4chdCID/Ttd9J1JUVKSWlha1t7erqKhIlZWV8vv92r17t7KysvTWW2+pqqpKZWVlGhwc1KpVq4ZjbgAecd0Rqa+vv+z49ddfv+JzJk2apMbGxj8/FYARg81mAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyuKyI9PT2aOnWqRo8erYMHD0qSamtrlZ2drcLCQnV2dkqSjhw5ory8PGVnZ2vXrl3uTw3AM64rIomJiaqrq9OcOXMkSQMDA6qurlZDQ4MqKipUWVkpSVq+fLnWrVun7du3a8WKFe5PDcAzrisi8fHxSk9Pjxx3dHRo4sSJ8vl8ysnJ0c8//yxJOnnypDIzM5WUlKTU1FSdOXPG3akBeEac5Rd3d3crKSkpcjw4OChJunjxYuSxMWPGqKurS2lpaQoGgwoGg5FzoVDIsjwADzBFJDk5Wb29vZHj2NhYSdKoUb/f4PT09Cg1NVWSFAgEFAgEIueKi4stywPwANO7M5mZmWpra1NfX5+ampo0efJkSVJGRoaOHTumcDgcuQsB8N/puu9EioqK1NLSovb2dj3//PMqLy9XQUGBEhISVFNTI0mqqqpSWVmZBgcHtWrVKteHBuAd1x2R+vr6Kx4rKSm57HjSpElqbGz881MBGDHYbAbAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAxByRixcvqqysTLm5ufL7/Tpy5Ij27t2r7Oxs+f1+tba2ujEnAI+Ks16gpaVFFy5cUGNjoxobG1VdXa329nbV1dUpHA5r4cKFqq+vd2NWAB5kjshdd90lx3HkOI66u7t1yy23KDY2VikpKUpJSVFXV5cbcwLwKHNE0tLSFB8frwkTJui3335TY2OjXnrppd8XiItTX1+ffD6fgsGggsFg5FwoFLIuDyDKzBHZsWOH4uLi1N7erubmZr366qvq7e2NnB8YGJDP55MkBQIBBQKByLni4mLr8gCizBwRx3F02223Sbp0VxIOhzUwMKCzZ88qHA4rNTXVPCQA7zJHZMaMGdqwYYPy8/N14cIFVVdXa2BgQEVFRYqJidHatWvdmBOAR5kjEhcXp82bN1/xeFNTk/XSAEYANpsBMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLAhIgAMHElIg0NDSosLNS0adO0ZcsW7d27V9nZ2fL7/WptbXVjCQAeFWe9wPnz57VmzRpt27ZNPp9PkpSfn6+6ujqFw2EtXLhQ9fX15kEBeJM5Ivv379fNN9+s2bNnKzExUWvXrlVsbKxSUlKUkpKirq4uN+YE4FHmiJw6dUpHjx7Vd999p507d2rlypVKSkr6fYG4OPX19cnn8ykYDCoYDEbOhUIh6/IAoswckeTkZOXk5Mjn86mwsFArV67UrbfeGjk/MDAQeZkTCAQUCAQi54qLi63LA4gy8xdWH330UbW1tclxHLW0tGjSpEkaGBjQ2bNn9csvvyg1NdWNOQF4lPlOJC0tTU8++aTy8/MVExOjTz/9VCdOnFBRUZFiYmK0du1aN+YE4FHmiEjS4sWLtXjx4sjxPffco6amJjcuDcDj2GwGwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAE1d+eBV+d/c/61y/5r9W/8P1awJu4U4EgAl3IoCHjYQ7W+5EAJgQEQAmrkVk06ZNSk9PlyTV1tYqOztbhYWF6uzsdGsJAB7kSkQGBwdVW1urcePGaWBgQNXV1WpoaFBFRYUqKyvdWAKAR7nyhdVNmzbp6aef1po1a9TR0aGJEyfK5/MpJydHS5cujXxeMBhUMBiMHIdCITeWBxBF5ogMDg7q888/15dffqk1a9aou7tbSUlJl53/t0AgoEAgEDkuLi62Lg8gyswR2bhxo5555hmNGnXplVFycrJ6e3sj52NjY61LYAQZCW9Jwl3miBw+fFg//fSTNm7cqI6ODr3//vtqa2tTX1+fmpubNXnyZDfmBOBR5oi8/fbbkY+nTJmiDz/8UJs3b1ZBQYESEhJUU1NjXQKAh7m6Y7W5uVmSVFJSopKSEjcvDcCj2GwGwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAEyICwISIADAhIgBMiAgAEyICwISIADAhIgBMbuifgDcc38pvOPAtB+Fl3IkAMCEiAEyICAATIgLAhIgAMCEiAEyICAATIgLA5IbebIaRgc123sadCAATIgLAhIgAMCEiAEzMEfnhhx+UlZWlvLw8zZs3T/39/aqtrVV2drYKCwvV2dnpxpwAPMockXHjxmn37t3as2eP7r77bm3dulXV1dVqaGhQRUWFKisr3ZgTgEeZ3+LNyMiIfOzz+dTe3q6JEyfK5/MpJydHS5cujZwPBoMKBoOR41AoZF0eQJS5tk/k+PHj2rFjh1avXq3Tp09HHh8cHIx8HAgEFAgEIsfFxcVuLQ8gSlyJSG9vr0pLS7VhwwYNDg6qt7c3ci42NtaNJQB4lDkiAwMDmjt3rlauXKn77rtP/f39amtrU19fn5qbmzV58mQ35gTgUeaIbNq0Sd9//70qKytVWVmpRYsWqby8XAUFBUpISFBNTY0bc8JlI+X7y8L7zBEpLS1VaWnpFY+XlJRYLw1gBGCzGQATIgLAhIgAMCEiAEyICAATIgLAhIgAMOF7rOKGxGY793AnAsCEiAAwISIATIgIABMiAsCEiAAwISIATIgIABMiAsCEiAAwISIATIgIABMiAsCEiAAwISIATIgIABMiAsCEiAAwISIATIgIABMiAsBk2CKybNky5ebmqrS0VP39/cO1DIAoG5aIHDhwQCdOnFBjY6MmTJigL774YjiWAeABw/JzZ5qamjRz5kxJ0qxZs7R+/XrNmzdPwWBQwWAw8nkHDhxQcXHxNV3zb6GQbr/99uEY11Uh5nTdSJl1pMz5+OOV1zznnXfeqQ8//HDoT3KGQVVVlbNlyxbHcRyno6PDmTdvnvmar7zyivkafwXmdN9ImfVGnXNYXs4kJyert7dXktTT06PU1NThWAaABwxLRLKzs7Vz505JUjAYVE5OznAsA8ADhiUiDz30kO644w7l5ubq0KFDeuqpp8zXDAQCLkw2/JjTfSNl1ht1zhjHcRxXrwjghsJmMwAmnozIH21UGxwc1HPPPafc3FyVl5dHb8D/9UdzfvXVV3rsscfk9/v18ssvR3HCS6628W/16tWaMmVKFCa70lCzfvbZZ5o+fboKCgq0f//+KE14yR/Nef78ec2ePVv5+fkqLCzUqVOnojjlpTc2pk6dqtGjR+vgwYOXnXPr+eS5iAy1Ue3rr7/W2LFj1djYqHPnzkX1L9JQcz744IPat2+f9u7dq1AopObmZk/OKUnhcFitra1Rmu5yQ8168uRJbd26Vbt27VJDQ4OysrI8Oee2bdv0wAMP6Ntvv1VZWZnWrVsXtTklKTExUXV1dZozZ84V59x6PnkuIv93o9q+ffuu6dxfbahZ/v73vysu7tI+Pp/Pp1GjovfbfLXfs/fee08vvvhiNEa7wlCzbt++XTfddJNmzJih0tJS/frrr9Eac8g57733Xp07d06S1N3drbS0tKjM+G/x8fFKT0//f8+59XzyXES6u7uVlJQkSRozZoy6urqu6dxf7Vpm+fHHHxUKhfTwww//1eNFDDVnT0+PWltbo/qv+n8aatZTp07pzJkz+uabb5SVlaUPPvggWmMOOWdmZqYOHz6s+++/Xx999JHmz58frTGvyq3nk+ciMtRGNS9tYrvaLJ2dnSovL1dNTU00xosYas53331XS5YsidZoV7jan/20adMUExOjwsJCHTp0KFpjDjlnTU2N/H6/Dh06pIqKClVWVkZrzKty6/nkuYgMtVHNS5vYhpolHA5r7ty5+vjjj6P+fymGmvPo0aN68803NWvWLHV0dKiqqipaY0oaetacnBy1tLRIklpaWjR+/PhojChp6Dkdx4m8hElLS1NPT09UZrwWrj2fXN1E75KlS5c6fr/fmT9/vnPhwgVnwYIFjuM4Tn9/v/Pss886fr/fWbJkSZSn/OM5KyoqnLFjxzr5+flOfn6+09DQ4Mk5/9MjjzwShcmuNNSsr732mpOfn+/MnDnTOX36dBSn/OM5z5496wQCASc/P9/x+/1Oe3t7VOd0HMd54oknnIyMDOfxxx931q9f7/rzic1mAEw893IGwMhCRACYEBEAJkQEgAkRAWBCRACYEBEAJkQEgAkRAWBCRACY/A85CsMgxCxiGgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(3,3))\n",
    "plt.hist(new_df['best_match_coverage'])\n",
    "\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112\n",
      "(239, 11)\n"
     ]
    }
   ],
   "source": [
    "# save the dataframe where the coverage is < 50%\n",
    "mismatch_res = new_df[new_df['covered_by_best_match'] == False]\n",
    "\n",
    "print(mismatch_res[mismatch_res['gpt_4_default Score Bin'] == 'High Confidence'].shape[0])\n",
    "\n",
    "print(mismatch_res.shape)\n",
    "mismatch_res.to_csv('data/GO_term_analysis/LLM_processed_selected_1000_go_terms_mismatch_subset.tsv', sep='\\t')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Medium Confidence    120\n",
       "High Confidence      112\n",
       "Low Confidence         6\n",
       "Name not assigned      1\n",
       "Name: gpt_4_default Score Bin, dtype: int64"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "mismatch_res = pd.read_csv('data/GO_term_analysis/LLM_processed_selected_1000_go_terms_mismatch_subset.tsv', sep='\\t')\n",
    "mismatch_res['gpt_4_default Score Bin'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## hypergeometric test res of all cases with best matching GO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns \n",
    "from scipy.stats import mannwhitneyu\n",
    "from matplotlib.ticker import FuncFormatter, MultipleLocator\n",
    "\n",
    "cutoff = 0.05\n",
    "df = pd.read_csv('data/GO_term_analysis/simrank_pval_LLM_processed_selected_1000_go_terms.tsv', sep='\\t')\n",
    "# I need to remove rows that names are 'System of unrelated proteins'\n",
    "df = df[df['gpt_4_default Name'] != 'System of unrelated proteins']\n",
    "print(len(df))\n",
    "\n",
    "top1_q = df['adj_pvals'].str.split('|').apply(lambda x: float(x[0]))\n",
    "random_q = df['random_adj_pvals'].apply(lambda x: float(x))\n",
    "\n",
    "# -log signifiance\n",
    "# calculate -log(q)\n",
    "eps = 1e-10\n",
    "top1_q_log = -np.log10(top1_q+eps)\n",
    "random_q_log = -np.log10(random_q+eps)\n",
    "print(len(top1_q_log), len(random_q_log))\n",
    "print('Median of top1_q_log: ', top1_q_log.median(), 'raw: ', top1_q.median())\n",
    "print('Median of random_q_log: ', random_q_log.median(), 'raw: ', random_q.median())\n",
    "significant = -np.log10(cutoff+eps)\n",
    "print(significant)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(3,3))\n",
    "\n",
    "# add statistical test \n",
    "\n",
    "diff_p = mannwhitneyu(top1_q_log, random_q_log)[1]\n",
    "print('p-value of Mann-Whitney U test: ', diff_p)\n",
    "\n",
    "sns.violinplot(data=[top1_q_log, random_q_log], ax=ax, palette=['#FBF49C', '#B3B3B3'], inner='quartile', cut=0, split=True, width=1, linewidth=0.5)\n",
    "\n",
    "\n",
    "\n",
    "def format_func(value, tick_number):\n",
    "    if value >= 0:\n",
    "        return f'$10^{{-{int(value)}}}$'\n",
    "    else:\n",
    "        return f'$10^{{{-int(value)}}}$'\n",
    "\n",
    "ax.yaxis.set_major_formatter(FuncFormatter(format_func))\n",
    "ax.yaxis.set_major_locator(MultipleLocator(1))\n",
    "\n",
    "ax.set_ylabel(\"Significance of overlap (q-value)\\nwith gene set query\")\n",
    "\n",
    "ax.axhline(significant, ls='--', color='red', alpha=0.5, label=f'q={cutoff}')\n",
    "ax.legend(loc='upper right', fontsize = 6)\n",
    "ax.set_xticklabels([\"Best match GO name\", \"Random GO name\"])\n",
    "# Get the current x-limits\n",
    "x_min, x_max = ax.get_xlim()\n",
    "\n",
    "# Set new x-limits with more space on the left\n",
    "ax.set_xlim(x_min - 0.005, x_max)\n",
    "\n",
    "# Calculate the number of significant best match GOs\n",
    "n_significant = (top1_q < cutoff).sum()\n",
    "\n",
    "# Add text above the line showing the number of significant best match GOs\n",
    "ax.text(0.5, significant + 0.5, f'N significant = {n_significant}', color='red', ha='center')\n",
    "\n",
    "# add significance bar\n",
    "\n",
    "max_y = max(max(top1_q_log), max(random_q_log))+0.03  # find the maximum y value with some gap\n",
    "bar_height = max_y * 0.08  # set height of the bar to be 8% of the maximum y value\n",
    "bar_start = 0 \n",
    "bar_end = 1 \n",
    "\n",
    "plt.plot([bar_start, bar_end], [max_y + bar_height, max_y + bar_height], color='black', linewidth = 0.5)  # plot horizontal line\n",
    "# plt.plot([bar_start, bar_start], [max_y, max_y + bar_height], color='black')  # plot vertical line at start of the bar\n",
    "# plt.plot([bar_end, bar_end], [max_y, max_y + bar_height], color='black')  # plot vertical line at end of the bar\n",
    "\n",
    "# add asterisks or other text to indicate the level of significance\n",
    "if diff_p < 0.0001:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"****\", ha='center')\n",
    "elif diff_p < 0.001:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"***\", ha='center')\n",
    "elif diff_p < 0.01:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"**\", ha='center')\n",
    "elif diff_p < 0.05:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"*\", ha='center')\n",
    "else:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"ns\", ha='center')\n",
    "\n",
    "\n",
    "sns.despine()\n",
    "\n",
    "plt.savefig(\"figures/LLM_name_GO_term_bestmatch_logq_violin_cutoff005.svg\", bbox_inches='tight')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns \n",
    "from scipy.stats import mannwhitneyu\n",
    "from matplotlib.ticker import FuncFormatter, MultipleLocator\n",
    "\n",
    "cutoff = 0.05\n",
    "df = pd.read_csv('data/GO_term_analysis/simrank_pval_LLM_processed_selected_1000_go_terms.tsv', sep='\\t')\n",
    "\n",
    "# also filter out thing with true_GO_term_sim_percentile >=0.95\n",
    "df_filtered = df[df['true_GO_term_sim_percentile'] < 0.95]\n",
    "print(len(df_filtered))\n",
    "# for the bottom 500, how many have name 'System of unrelated proteins', remove\n",
    "# because System of unrelated proteins will not have a best name that covers>50% of the genes\n",
    "df_filtered = df_filtered[df_filtered['gpt_4_default Name']!= 'System of unrelated proteins']\n",
    "\n",
    "df = df_filtered\n",
    "\n",
    "top1_q = df['adj_pvals'].str.split('|').apply(lambda x: float(x[0]))\n",
    "random_q = df['random_adj_pvals'].apply(lambda x: float(x))\n",
    "\n",
    "# -log signifiance\n",
    "# calculate -log(q)\n",
    "eps = 1e-10\n",
    "top1_q_log = -np.log10(top1_q+eps)\n",
    "random_q_log = -np.log10(random_q+eps)\n",
    "print(len(top1_q_log), len(random_q_log))\n",
    "print('Median of top1_q_log: ', top1_q_log.median(), 'raw: ', top1_q.median())\n",
    "print('Median of random_q_log: ', random_q_log.median(), 'raw: ', random_q.median())\n",
    "significant = -np.log10(cutoff+eps)\n",
    "print(significant)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(3,3))\n",
    "\n",
    "# add statistical test \n",
    "\n",
    "diff_p = mannwhitneyu(top1_q_log, random_q_log)[1]\n",
    "print('p-value of Mann-Whitney U test: ', diff_p)\n",
    "\n",
    "sns.violinplot(data=[top1_q_log, random_q_log], ax=ax, palette=['#FBF49C', '#B3B3B3'], inner='quartile', cut=0, split=True, width=1, linewidth=0.5)\n",
    "\n",
    "\n",
    "\n",
    "def format_func(value, tick_number):\n",
    "    if value >= 0:\n",
    "        return f'$10^{{-{int(value)}}}$'\n",
    "    else:\n",
    "        return f'$10^{{{-int(value)}}}$'\n",
    "\n",
    "ax.yaxis.set_major_formatter(FuncFormatter(format_func))\n",
    "ax.yaxis.set_major_locator(MultipleLocator(1))\n",
    "\n",
    "ax.set_ylabel(\"Significance of overlap (q-value)\\nwith gene set query\")\n",
    "\n",
    "ax.axhline(significant, ls='--', color='red', alpha=0.5, label=f'q={cutoff}')\n",
    "ax.legend(loc='upper right', fontsize = 6)\n",
    "ax.set_xticklabels([\"Best match GO name\", \"Random GO name\"])\n",
    "# Get the current x-limits\n",
    "x_min, x_max = ax.get_xlim()\n",
    "\n",
    "# Set new x-limits with more space on the left\n",
    "ax.set_xlim(x_min - 0.005, x_max)\n",
    "\n",
    "# Calculate the number of significant best match GOs\n",
    "n_significant = (top1_q < cutoff).sum()\n",
    "\n",
    "# Add text above the line showing the number of significant best match GOs\n",
    "ax.text(0.5, significant + 0.5, f'N significant = {n_significant}', color='red', ha='center')\n",
    "\n",
    "# add significance bar\n",
    "\n",
    "max_y = max(max(top1_q_log), max(random_q_log))+0.03  # find the maximum y value with some gap\n",
    "bar_height = max_y * 0.08  # set height of the bar to be 8% of the maximum y value\n",
    "bar_start = 0 \n",
    "bar_end = 1 \n",
    "\n",
    "plt.plot([bar_start, bar_end], [max_y + bar_height, max_y + bar_height], color='black', linewidth = 0.5)  # plot horizontal line\n",
    "# plt.plot([bar_start, bar_start], [max_y, max_y + bar_height], color='black')  # plot vertical line at start of the bar\n",
    "# plt.plot([bar_end, bar_end], [max_y, max_y + bar_height], color='black')  # plot vertical line at end of the bar\n",
    "\n",
    "# add asterisks or other text to indicate the level of significance\n",
    "if diff_p < 0.0001:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"****\", ha='center')\n",
    "elif diff_p < 0.001:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"***\", ha='center')\n",
    "elif diff_p < 0.01:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"**\", ha='center')\n",
    "elif diff_p < 0.05:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"*\", ha='center')\n",
    "else:\n",
    "    plt.text((bar_start + bar_end) / 2, max_y + bar_height, \"ns\", ha='center')\n",
    "\n",
    "\n",
    "sns.despine()\n",
    "\n",
    "# plt.savefig(\"figures/LLM_name_GO_term_bestmatch_logq_violin_cutoff005.svg\", bbox_inches='tight')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm",
   "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.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}