result_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd \n",
    "import scipy\n",
    "import seaborn as sns\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "import glob\n",
    "import matplotlib\n",
    "import scipy\n",
    "from config import *\n",
    "matplotlib.rcParams[\"svg.fonttype\"] = \"none\"\n",
    "matplotlib.rcParams[\"text.usetex\"] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sanity check\n",
    "universes = [\n",
    "        \"tile1k\",\n",
    "        \"tile5k\",\n",
    "        \"tile25k\",\n",
    "        \"dhs\",\n",
    "        \"Large\",\n",
    "        \"Medium\",\n",
    "        \"Small\",\n",
    "    ]\n",
    "gdss_path = os.path.join(EVAL_RESULTS_FOLDER, \"gdss_results\")\n",
    "for universe in universes:\n",
    "    upath = os.path.join(gdss_path, universe)\n",
    "    if os.path.exists(upath):\n",
    "        files = glob.glob(os.path.join(upath,\"gdss_eval*\"))\n",
    "        if len(files) != 20:\n",
    "            print(f\"[GDSS] Incomplete {universe}\")\n",
    "    else:\n",
    "        print(f\"[GDSS] Incomplete {universe}\")\n",
    "        \n",
    "nps_path = os.path.join(EVAL_RESULTS_FOLDER, \"nps_results\")\n",
    "for universe in universes:\n",
    "    upath = os.path.join(nps_path, universe)\n",
    "    if os.path.exists(upath):\n",
    "        files = glob.glob(os.path.join(upath,\"nps_eval*\"))\n",
    "        if len(files) != 20:\n",
    "            print(f\"[NPS] Incomplete {universe}\")\n",
    "    else:\n",
    "        print(f\"[NPS] Incomplete {universe}\")\n",
    "        \n",
    "\n",
    "cts_path = os.path.join(EVAL_RESULTS_FOLDER, \"cts_results\")\n",
    "for universe in universes:\n",
    "    upath = os.path.join(cts_path, universe)\n",
    "    if os.path.exists(upath):\n",
    "        files = glob.glob(os.path.join(upath,\"cts_eval*\"))\n",
    "        if len(files) != 20:\n",
    "            print(f\"[cts] Incomplete {universe}\")\n",
    "    else:\n",
    "        print(f\"[CTS] Incomplete {universe}\")\n",
    "\n",
    "rcs_path = os.path.join(EVAL_RESULTS_FOLDER, \"rcs_results\")\n",
    "for universe in universes:\n",
    "    upath = os.path.join(rcs_path, universe)\n",
    "    if os.path.exists(upath):\n",
    "        files = glob.glob(os.path.join(upath,\"rcs_eval*\"))\n",
    "        if len(files) != 5:\n",
    "            print(f\"[RCS] Incomplete {universe}\")\n",
    "    else:\n",
    "        print(f\"[RCS] Incomplete {universe}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_name(path):\n",
    "    if 'pickle' in path:\n",
    "        name = path.split('.')[0].strip()\n",
    "        if 'bin' in name:\n",
    "            name = 'Binary'\n",
    "        elif 'pca' in name:\n",
    "            name = \"PCA-{}\".format(name.split(\"_\")[-1].strip())\n",
    "    else:\n",
    "        name = path.split('/')[-3]\n",
    "    return name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cts_results(universe):\n",
    "    paths = glob.glob(f\"{EVAL_RESULTS_FOLDER}/cts_results/{universe}/cts_eval_seed*\")\n",
    "    cts_scores = {}\n",
    "    for path in paths:\n",
    "        with open(path, \"rb\") as f:\n",
    "            results = pickle.load(f)\n",
    "        for result in results:\n",
    "            name = extract_name(result[0])\n",
    "            score = max(result[1]-0.5,0)*2 # rescale the score\n",
    "            if name in cts_scores:\n",
    "                cts_scores[name].append(score)\n",
    "            else:\n",
    "                cts_scores[name] = [score]\n",
    "    names = list(cts_scores.keys())\n",
    "    cts_scores = np.array([cts_scores[n] for n in names])\n",
    "    if len(cts_scores.shape) == 1:\n",
    "        cts_scores = cts_scores.reshape(len(cts_scores),1)\n",
    "    cts_avg = cts_scores.mean(axis=1)\n",
    "    cts_std = cts_scores.std(axis=1)\n",
    "    indexes = np.argsort(cts_avg)\n",
    "    cts_avg = cts_avg[indexes]\n",
    "    cts_std = cts_std[indexes]\n",
    "    names = [names[i] for i in indexes]\n",
    "    return cts_avg, cts_std, names\n",
    "\n",
    "def get_cts_plot(universe, save_fig=False):\n",
    "    paths = glob.glob(f\"{EVAL_RESULTS_FOLDER}/cts_results/{universe}/cts_eval_seed*\")\n",
    "    cts_scores = {}\n",
    "    for path in paths:\n",
    "        with open(path, \"rb\") as f:\n",
    "            results = pickle.load(f)\n",
    "        for result in results:\n",
    "            name = extract_name(result[0])\n",
    "            score = max(result[1]-0.5,0)*2 # rescale the score\n",
    "            if name in cts_scores:\n",
    "                cts_scores[name].append(score)\n",
    "            else:\n",
    "                cts_scores[name] = [score]\n",
    "    names = list(cts_scores.keys())\n",
    "    cts_scores = np.array([cts_scores[n] for n in names])\n",
    "    if len(cts_scores.shape) == 1:\n",
    "        cts_scores = cts_scores.reshape(len(cts_scores),1)\n",
    "    cts_avg = cts_scores.mean(axis=1)\n",
    "    cts_std = cts_scores.std(axis=1)\n",
    "    indexes = np.argsort(cts_avg)\n",
    "    cts_avg = cts_avg[indexes]\n",
    "    cts_std = cts_std[indexes]\n",
    "    names = [names[i] for i in indexes]\n",
    "    cmap = plt.get_cmap(\"Blues\")\n",
    "    colors = cmap(np.linspace(0, 1, 5))\n",
    "    fig, ax = plt.subplots(figsize=(5,5))\n",
    "    y_pos = np.arange(len(names))\n",
    "    ax.barh(y_pos, cts_avg, xerr=cts_std, align='center',color=colors[2])\n",
    "    ax.set_yticks(y_pos, labels=names)\n",
    "    for item in (ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "        item.set_fontsize(16)\n",
    "    ax.set_xlabel('CTS', fontsize=16)\n",
    "    \n",
    "    \n",
    "    if save_fig:\n",
    "        os.makedirs(f\"{EVAL_RESULTS_FOLDER}/scores_visualization/cts_results\",exist_ok=True)\n",
    "        fig.savefig(f\"{EVAL_RESULTS_FOLDER}/scores_visualization/cts_results/cts_{universe}.svg\", bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "for u in universes:\n",
    "    get_cts_plot(u, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rcs_results(universe, paths=None):\n",
    "    if paths is None:\n",
    "        paths = glob.glob(f\"{EVAL_RESULTS_FOLDER}/rcs_results/{universe}/rcs_eval_seed*\")\n",
    "    \n",
    "    rcs_dict = {}\n",
    "    for path in paths:\n",
    "        with open(path, \"rb\") as f:\n",
    "            results = pickle.load(f)\n",
    "        for result in results:\n",
    "            name = extract_name(result[0])\n",
    "            if name in rcs_dict:\n",
    "                rcs_dict[name].append(result[1])\n",
    "            else:\n",
    "                rcs_dict[name] = [result[1]]\n",
    "    names = []\n",
    "    rcs_scores = []\n",
    "    rcs_stds = []\n",
    "    for k in rcs_dict:\n",
    "        names.append(k)\n",
    "        scores = np.array(rcs_dict[k]).mean()\n",
    "        avg_score = scores.mean()\n",
    "        rcs_scores.append(avg_score)\n",
    "        std_score = scores.std()\n",
    "        rcs_stds.append(std_score)\n",
    "    rcs_stds = np.array(rcs_stds)\n",
    "    rcs_scores = np.array(rcs_scores)\n",
    "    indexes = np.argsort(rcs_scores)\n",
    "    rcs_scores = rcs_scores[indexes]\n",
    "    rcs_stds = rcs_stds[indexes]\n",
    "    names = [names[i] for i in indexes]\n",
    "    return rcs_scores, rcs_stds, names\n",
    "\n",
    "def get_rcs_plot(universe, save_fig=False):\n",
    "    paths = glob.glob(f\"{EVAL_RESULTS_FOLDER}/rcs_results/{universe}/rcs_eval_seed*\")\n",
    "    rcs_scores = {}\n",
    "    for path in paths:\n",
    "        with open(path, \"rb\") as f:\n",
    "            results = pickle.load(f)\n",
    "        for result in results:\n",
    "            name = extract_name(result[0])\n",
    "            score = result[1]\n",
    "            if name in rcs_scores:\n",
    "                rcs_scores[name].append(score)\n",
    "            else:\n",
    "                rcs_scores[name] = [score]\n",
    "    names = list(rcs_scores.keys())\n",
    "    rcs_scores = np.array([rcs_scores[n] for n in names])\n",
    "    if len(rcs_scores.shape) == 1:\n",
    "        rcs_scores = rcs_scores.reshape(len(rcs_scores),1)\n",
    "    rcs_avg = rcs_scores.mean(axis=1)\n",
    "    rcs_std = rcs_scores.std(axis=1)\n",
    "    indexes = np.argsort(rcs_avg)\n",
    "    rcs_avg = rcs_avg[indexes]\n",
    "    rcs_std = rcs_std[indexes]\n",
    "    names = [names[i] for i in indexes]\n",
    "    cmap = plt.get_cmap(\"Blues\")\n",
    "    colors = cmap(np.linspace(0, 1, 5))\n",
    "    fig, ax = plt.subplots(figsize=(5,5))\n",
    "    y_pos = np.arange(len(names))\n",
    "    ax.barh(y_pos, rcs_avg, xerr=rcs_std, align='center',color=colors[2])\n",
    "    ax.set_yticks(y_pos, labels=names)\n",
    "    for item in (ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "        item.set_fontsize(16)\n",
    "    ax.set_xlabel('RCS', fontsize=16)\n",
    "    \n",
    "    if save_fig:\n",
    "        os.makedirs(f\"{EVAL_RESULTS_FOLDER}/scores_visualization/rcs_results\",exist_ok=True)\n",
    "        fig.savefig(f\"{EVAL_RESULTS_FOLDER}/scores_visualization/rcs_results/rcs_{universe}.svg\", bbox_inches=\"tight\")\n",
    "    plt.close()\n",
    "    # plt.show()\n",
    "for u in universes:\n",
    "    get_rcs_plot(u, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_gdss_results(result_path):\n",
    "    universe = result_path.split('/')[-2]\n",
    "    gds_seeds = glob.glob(result_path)\n",
    "    gds_arr = [[] for i in range(15)]\n",
    "    names = ['' for i in range(15)]\n",
    "    for gds_seed in gds_seeds:\n",
    "        with open(gds_seed,'rb') as f:\n",
    "            results = pickle.load(f)\n",
    "            for i,res in enumerate(results):\n",
    "                name = extract_name(res[0])\n",
    "                gds_arr[i].append(res[1])\n",
    "                names[i] = name\n",
    "    name_dict = {n:i for i,n in enumerate(names)}\n",
    "    gds_arr = np.array(gds_arr)\n",
    "    gds_std = gds_arr.std(axis=1)\n",
    "    gds_median = np.median(gds_arr,axis=1)\n",
    "    \n",
    "    \n",
    "    indexes = np.argsort(-gds_median)\n",
    "    gds_median = -np.sort(-gds_median)\n",
    "    names = [names[i] for i in indexes]\n",
    "    return gds_median, names\n",
    "\n",
    "def produce_gdss_plots(result_path, save_folder, save_fig=False):\n",
    "    os.makedirs(save_folder,exist_ok=True)\n",
    "    universe = result_path.split('/')[-2]\n",
    "    gds_seeds = glob.glob(result_path)\n",
    "    gds_arr = [[] for i in range(15)]\n",
    "    names = ['' for i in range(15)]\n",
    "    for gds_seed in gds_seeds:\n",
    "        with open(gds_seed,'rb') as f:\n",
    "            results = pickle.load(f)\n",
    "            for i,res in enumerate(results):\n",
    "                name = extract_name(res[0])\n",
    "                gds_arr[i].append(res[1])\n",
    "                names[i] = name\n",
    "    name_dict = {n:i for i,n in enumerate(names)}\n",
    "    gds_arr = np.array(gds_arr)\n",
    "    gds_std = gds_arr.std(axis=1)\n",
    "    gds_median = np.median(gds_arr,axis=1)\n",
    "    \n",
    "    \n",
    "    indexes = np.argsort(-gds_median)\n",
    "    \n",
    "    y_pos = np.arange(len(gds_median))\n",
    "    sorted_gds_arr = [gds_arr[i] for i in indexes]\n",
    "    fig, ax = plt.subplots(figsize=(5,5))\n",
    "    _ = ax.violinplot(sorted_gds_arr,y_pos,vert=False,showmedians=True,showextrema=False,widths=0.8)\n",
    "    ax.invert_yaxis()\n",
    "    _ = ax.set_yticks(y_pos, labels=[names[i] for i in indexes])\n",
    "    ax.grid(axis=\"y\")\n",
    "    ax.set_xlabel(\"GDSS ($10^{-10}$)\",fontsize=16)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['bottom'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "\n",
    "    for item in (ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "        item.set_fontsize(16)\n",
    "    if save_fig:\n",
    "        file_name = os.path.join(save_folder, \"gdss_{}.svg\".format(universe))\n",
    "        fig.savefig(file_name, bbox_inches=\"tight\")\n",
    "    plt.show()\n",
    "\n",
    "gdss_result_batch = [f\"{EVAL_RESULTS_FOLDER}/gdss_results/{u}/gdss_eval_seed*\" for u in universes]\n",
    "for path in gdss_result_batch:\n",
    "    produce_gdss_plots(path, f\"{EVAL_RESULTS_FOLDER}/scores_visualization/gdss_results/\", True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_nps_results(result_path, Kidx=0):\n",
    "    universe = result_path.split('/')[-2]\n",
    "    nps_seeds = glob.glob(result_path)\n",
    "    \n",
    "    snpr_arr = [[] for i in range(15)]\n",
    "    names = ['' for i in range(15)]\n",
    "    for nps_seed in nps_seeds:\n",
    "        with open(nps_seed,'rb') as f:\n",
    "            result = pickle.load(f)\n",
    "        for i, res in enumerate(result):\n",
    "            snpr_arr[i].append(res['SNPR'])\n",
    "            name = extract_name(res['Path'])\n",
    "            names[i] = name\n",
    "    snpr_arr_k = [np.array(s)[:,Kidx] for s in snpr_arr]  \n",
    "    snprs_median = np.array([np.median(s) for s in snpr_arr_k])\n",
    "    indexes = np.argsort(-snprs_median)\n",
    "    snprs_median = [snprs_median[i] for i in indexes]\n",
    "    names = [names[i] for i in indexes]\n",
    "    return snprs_median, names\n",
    "\n",
    "def produce_nps_plots(result_path, save_folder, Kidx=0):\n",
    "    os.makedirs(save_folder,exist_ok=True)\n",
    "    universe = result_path.split('/')[-2]\n",
    "    nps_seeds = glob.glob(result_path)\n",
    "    \n",
    "    snpr_arr = [[] for i in range(15)]\n",
    "    names = ['' for i in range(15)]\n",
    "    for nps_seed in nps_seeds:\n",
    "        with open(nps_seed,'rb') as f:\n",
    "            result = pickle.load(f)\n",
    "        for i, res in enumerate(result):\n",
    "            snpr_arr[i].append(res['SNPR'])\n",
    "            name = extract_name(res['Path'])\n",
    "            names[i] = name\n",
    "    \n",
    "    snpr_arr_k = [np.stack(s)[:,Kidx] for s in snpr_arr]  \n",
    "    snprs_avg = np.array([s.mean() for s in snpr_arr_k]) # select the first element\n",
    "    snprs_median = np.array([np.median(s) for s in snpr_arr_k])\n",
    "    name_dict = {n:i for i,n in enumerate(names)}\n",
    "    \n",
    "    indexes = np.argsort(-snprs_median)\n",
    "    sorted_snpr_arr = [snpr_arr_k[i] for i in indexes]\n",
    "    y_pos = np.arange(len(sorted_snpr_arr))\n",
    "    fig, ax = plt.subplots(figsize=(5,5))\n",
    "    ax.set_yticks(y_pos, labels=[names[i] for i in indexes])\n",
    "    # ax.barh(y_pos, sort_snprs,align='center')\n",
    "    \n",
    "    _ = ax.violinplot(sorted_snpr_arr,y_pos,vert=False,showmedians=True,showextrema=False,widths=0.8)\n",
    "    ax.invert_yaxis()\n",
    "    _ = ax.set_yticks(y_pos, labels=[names[i] for i in indexes])\n",
    "    ax.grid(axis=\"y\")\n",
    "    ax.set_xlabel(\"NPS\", fontsize=16)\n",
    "\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    # ax.spines['bottom'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    # ax.get_xaxis().set_ticks([])\n",
    "    for item in (ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "        item.set_fontsize(16)\n",
    "    file_name = os.path.join(save_folder, \"nps_{}.svg\".format(universe))\n",
    "    \n",
    "    fig.savefig(file_name, bbox_inches=\"tight\")\n",
    "    fig.clf()\n",
    "    plt.close()\n",
    "    \n",
    "nps_result_batch = [f\"{EVAL_RESULTS_FOLDER}/nps_results/{u}/nps_eval_seed*\" for u in universes]\n",
    "for path in nps_result_batch:\n",
    "    produce_nps_plots(path, f\"{EVAL_RESULTS_FOLDER}/scores_visualization/nps_results/\", 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_svm = pd.read_csv(\"classificaton_results_svm.txt\")    \n",
    "data_svm = pd.concat([data_svm[data_svm['universe'] == u] for u in universes], ignore_index=True)\n",
    "def remap_name(name):\n",
    "    if \"bin_embed\" in name:\n",
    "        return \"Binary\"\n",
    "    elif \"pca_embed_10D\" in name:\n",
    "        return \"PCA-10D\"\n",
    "    elif \"pca_embed_100D\" in name:\n",
    "        return \"PCA-100D\"\n",
    "    else:\n",
    "        return name\n",
    "data_svm[\"model\"] = data_svm[\"model\"].apply(remap_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_svm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_gdss_pd = []\n",
    "for u in universes:\n",
    "    gdss_scores, names = get_gdss_results(f\"{EVAL_RESULTS_FOLDER}/gdss_results/{u}/gdss_eval_seed*\")\n",
    "    eval_gdss_pd.append(pd.DataFrame({'universe':[u]*len(names), 'GDSS':gdss_scores, 'model':names}))\n",
    "eval_gdss_pd = pd.concat(eval_gdss_pd)  \n",
    "\n",
    "eval_nps_pd = []\n",
    "for u in universes:\n",
    "    nps_scores, names = get_nps_results(f\"{EVAL_RESULTS_FOLDER}/nps_results/{u}/nps_eval_seed*\", 9)\n",
    "    eval_nps_pd.append(pd.DataFrame({'universe':[u]*len(names), 'NPS':nps_scores, 'model':names})) \n",
    "eval_nps_pd = pd.concat(eval_nps_pd)\n",
    "\n",
    "eval_scores_pd = pd.merge(eval_gdss_pd, eval_nps_pd, how='left', on=['universe', 'model'])\n",
    "\n",
    "eval_cts_pd = []\n",
    "for u in universes:\n",
    "    cts_scores, cts_stds, names = get_cts_results(u)\n",
    "    cts_scores = np.maximum(cts_scores-0.5,0) * 2\n",
    "    eval_cts_pd.append(pd.DataFrame({'universe':[u]*len(names), 'CTS':cts_scores, 'model':names})) \n",
    "eval_cts_pd = pd.concat(eval_cts_pd)\n",
    "\n",
    "eval_scores_pd = eval_scores_pd.merge(eval_cts_pd, how='left', on=['universe', 'model'])\n",
    "\n",
    "eval_rcs_pd = []\n",
    "for u in universes:\n",
    "    rcs_scores, rcs_stds, names = get_rcs_results(u)\n",
    "    eval_rcs_pd.append(pd.DataFrame({'universe':[u]*len(names), 'RCS':rcs_scores, 'model':names})) \n",
    "eval_rcs_pd = pd.concat(eval_rcs_pd)\n",
    "\n",
    "eval_scores_pd = eval_scores_pd.merge(eval_rcs_pd, how='left', on=['universe', 'model'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_scores_svm = data_svm.merge(eval_scores_pd, how='left', on=['universe', 'model'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pairgird(dataframe):\n",
    "    g = sns.PairGrid(dataframe)\n",
    "    def print_stats(x,**kws):\n",
    "        ax = plt.gca()\n",
    "        ax.text(\n",
    "            .5, .5, x.name, size=14,\n",
    "            ha=\"center\", va=\"center\", transform=ax.transAxes\n",
    "        )\n",
    "    def regplot(x, y, **kw):\n",
    "        ax = plt.gca()\n",
    "        # colors = []\n",
    "        # for i, n in enumerate(x.index):\n",
    "        #     ax.annotate(n, (x[i],y[i]))\n",
    "        sns.regplot(x=x, y=y, ax=ax)\n",
    "        \n",
    "    g.map_diag(print_stats)\n",
    "    g.map_offdiag(regplot)\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataframe = all_scores_centroids[all_scores_centroids['universe'] == 'Large']\n",
    "dataframe = dataframe[['CTS','RCS','GDSS','NPS']]\n",
    "dataframe['GDSS'] = dataframe['GDSS'] * 1e-10\n",
    "fig = plot_pairgird(dataframe)\n",
    "fig.savefig(f\"{EVAL_RESULTS_FOLDER}/scores_visualization/corr_large.svg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cell CTT 0.2177152632492275 0.04333430061872965\n",
      "cell RCT 0.7815754985218587 0.03762097949943948\n",
      "cell GDST 0.481449691772419 0.15750271026855375\n",
      "cell NPT 0.8849686422002375 0.01146073696789036\n",
      "antibody CTT 0.1386218351187427 0.09260464656522456\n",
      "antibody RCT 0.762196187246839 0.05453073693544511\n",
      "antibody GDST 0.5184694519799277 0.1079406274713759\n",
      "antibody NPT 0.8765008568159824 0.025631889123376966\n"
     ]
    }
   ],
   "source": [
    "for class_type in [\"cell\", \"antibody\"]:\n",
    "    for test_type in [\"CTS\", \"RCS\", \"GDSS\", \"NPS\"]:\n",
    "        corrs = []\n",
    "        for u in universes:\n",
    "            condition = (all_scores_svm['universe']==u)\n",
    "            accs = all_scores_svm[condition][f'{class_type}_acc'].to_numpy()\n",
    "            gdsss = all_scores_svm[condition][test_type].to_numpy()\n",
    "            corr, _ = scipy.stats.pearsonr(accs, gdsss)\n",
    "            corrs.append((u,corr))\n",
    "\n",
    "        corr_vals = np.array([c[1] for c in corrs])\n",
    "        print(class_type, test_type, corr_vals.mean(), corr_vals.std())\n",
    "        # print(corrs)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}