random_forest/src/Overlap-Alt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bcfb10ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json \n",
    "import matplotlib\n",
    "from matplotlib import pyplot as plt\n",
    "import pickle\n",
    "import pandas as pd\n",
    "import numpy as np \n",
    "import sklearn \n",
    "import statistics\n",
    "from matplotlib.patches import Patch\n",
    "from matplotlib.lines import Line2D\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d337ae30",
   "metadata": {},
   "outputs": [],
   "source": [
    "full_data = pd.read_csv('../../data/raw-data/filtered_everything.csv', index_col=0)\n",
    "combined_test = pd.read_csv('../../data/splitted-data/everything/nbins-10/test_set.csv', index_col=0)\n",
    "m2575 = pd.read_csv('../../data/raw-data/unprocessed/mixed-25-75.csv', index_col=0)\n",
    "m2575_test = pd.read_csv('../../data/splitted-data/mixed2575/nbins-10/test_set.csv', index_col=0)\n",
    "m5050_test = pd.read_csv('../../data/splitted-data/mixed5050/nbins-10/test_set.csv', index_col=0)\n",
    "optimal = pd.read_csv('../../data/raw-data/opt_22_raw.csv', index_col=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "99a03b8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "oresults_path = '../predicted-results/original/nbins-10'\n",
    "mresults_path = '../predicted-results/mixed5050/nbins-10'\n",
    "eresults_path = '../predicted-results/everything/nbins-10'\n",
    "\n",
    "omodels_path = '../models/original'\n",
    "mmodels_path = '../models/mixed5050/nbins-10'\n",
    "emodels_path = '../models/everything/nbins-10'\n",
    "\n",
    "test_sets = ['5050', '2575', 'everything']\n",
    "\n",
    "mpoints = [100, 200, 300, 500, 1000, 1500, 2000, 2500, 'all']\n",
    "epoints = [100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 'all']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4d5284c",
   "metadata": {},
   "source": [
    "# Setting up and Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "827dda57",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Consider 5050 models and everything models at the 2500 mark \n",
    "m5models = dict()\n",
    "emodels = dict()\n",
    "omodels = dict()\n",
    "# 5050 model\n",
    "for tset in ['5050', '2575', 'everything']:\n",
    "    m5models[tset] = dict()\n",
    "    emodels[tset] = dict()\n",
    "    omodels[tset] = dict()\n",
    "    \n",
    "    '''First load the original models'''\n",
    "    for target in ['COF', 'intercept']:\n",
    "        with open(f'{omodels_path}/{target}.pickle', 'rb') as f:\n",
    "            model = pickle.load(f)\n",
    "        with open(f'{omodels_path}/{target}.ptxt', 'rb') as f:\n",
    "            features = pickle.load(f)\n",
    "        with open(f'{oresults_path}/{target}_on_{tset}.json', 'r') as f:\n",
    "            data = json.load(f)\n",
    "        omodels[tset][target] = {\n",
    "#                                 'model': model,\n",
    "                                 'features': features,\n",
    "                                 'data': data,\n",
    "                                 'n_train': len(model.oob_prediction_),\n",
    "                                 'r_square': data[target]['r_square']}\n",
    "        \n",
    "    '''Then load the mixed5050 models'''\n",
    "    for target in ['COF', 'intercept']:\n",
    "        m5models[tset][target] = dict()\n",
    "        for point in mpoints:\n",
    "            m5models[tset][target][point] = dict()\n",
    "            for i in range(5):\n",
    "                with open(f'{mmodels_path}/set_{i}/{target}_{point}.pickle', 'rb') as f:\n",
    "                    model = pickle.load(f)\n",
    "                with open(f'{mmodels_path}/set_{i}/{target}_{point}.ptxt', 'rb') as f:\n",
    "                    features = pickle.load(f)\n",
    "                with open(f'{mresults_path}/set_{i}/{target}_{point}_on_{tset}.json', 'r') as f :\n",
    "                    data = json.load(f)\n",
    "                \n",
    "                m5models[tset][target][point][f'set_{i}'] = dict()\n",
    "                m5models[tset][target][point][f'set_{i}'] = {\n",
    "#                  'model': model,\n",
    "                  'features': features,\n",
    "                  'data': data,\n",
    "                  'n_train': len(model.oob_prediction_),\n",
    "                  'r_square': data[target]['r_square']}\n",
    "\n",
    "                    \n",
    "    '''Finally load the combined models'''\n",
    "    for target in ['COF', 'intercept']:\n",
    "        emodels[tset][target] = dict()\n",
    "        for point in epoints:\n",
    "            emodels[tset][target][point] = dict()\n",
    "            for i in range(5):\n",
    "                with open(f'{emodels_path}/set_{i}/{target}_{point}.pickle', 'rb') as f:\n",
    "                    model = pickle.load(f)\n",
    "                with open(f'{emodels_path}/set_{i}/{target}_{point}.ptxt', 'rb') as f:\n",
    "                    features = pickle.load(f)\n",
    "                with open(f'{eresults_path}/set_{i}/{target}_{point}_on_{tset}.json', 'r') as f :\n",
    "                    data = json.load(f)\n",
    "                    \n",
    "                emodels[tset][target][point][f'set_{i}'] = dict()\n",
    "                emodels[tset][target][point][f'set_{i}'] = {\n",
    "#                  'model': model,\n",
    "                  'features': features,\n",
    "                  'data': data,\n",
    "                  'n_train': len(model.oob_prediction_),\n",
    "                  'r_square': data[target]['r_square']}\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f31af1df",
   "metadata": {},
   "outputs": [],
   "source": [
    "doi = {'omodels': dict(), \n",
    "       'mmodels': dict(), \n",
    "       'emodels': dict()}\n",
    "\n",
    "for tset in ['5050', '2575', 'everything']:\n",
    "    doi['omodels'][f'on_{tset}'] = dict()\n",
    "    for target in ['COF', 'intercept']:\n",
    "        doi['omodels'][f'on_{tset}'][target] = dict()\n",
    "        omoi = omodels[tset][target]\n",
    "        odoi = dict() \n",
    "        odoi['terminal_group_1'] = list()\n",
    "        odoi['terminal_group_2'] = list()\n",
    "        odoi['terminal_group_3'] = list()\n",
    "        odoi['frac-1'] = list() \n",
    "        odoi['frac-2'] = list()\n",
    "        odoi[f'predicted-{target}'] = list()\n",
    "        odoi[f'simulated-{target}'] = list()\n",
    "        for j in omoi['data'][target]:\n",
    "            if j != 'r_square':\n",
    "                odoi['terminal_group_1'].append(omoi['data'][target][j]['tg-1'])\n",
    "                odoi['terminal_group_2'].append(omoi['data'][target][j]['tg-2'])\n",
    "                odoi['terminal_group_3'].append(omoi['data'][target][j]['tg-3'])\n",
    "                odoi['frac-1'].append(omoi['data'][target][j]['frac-1'])\n",
    "                odoi['frac-2'].append(omoi['data'][target][j]['frac-2'])\n",
    "                odoi[f'predicted-{target}'].append(omoi['data'][target][j][f'predicted-{target}'])\n",
    "                odoi[f'simulated-{target}'].append(omoi['data'][target][j][f'simulated-{target}'])\n",
    "\n",
    "        doi['omodels'][f'on_{tset}'][target] = pd.DataFrame.from_dict(odoi)            \n",
    "\n",
    "    for point in mpoints: \n",
    "        doi['mmodels'][f'{point}_on_{tset}'] = dict() \n",
    "        for target in ['COF', 'intercept']:\n",
    "            doi['mmodels'][f'{point}_on_{tset}'][target] = dict()\n",
    "            for i in range(5):\n",
    "                doi['mmodels'][f'{point}_on_{tset}'][target][f'set_{i}'] = dict()\n",
    "                mmoi = m5models[tset][target][point][f'set_{i}']\n",
    "                mdoi = dict() \n",
    "                mdoi['terminal_group_1'] = list()\n",
    "                mdoi['terminal_group_2'] = list()\n",
    "                mdoi['terminal_group_3'] = list()\n",
    "                mdoi['frac-1'] = list() \n",
    "                mdoi['frac-2'] = list()\n",
    "                mdoi[f'predicted-{target}'] = list()\n",
    "                mdoi[f'simulated-{target}'] = list()\n",
    "                for j in mmoi['data'][target]:\n",
    "                    if j != 'r_square':\n",
    "                        mdoi['terminal_group_1'].append(mmoi['data'][target][j]['tg-1'])\n",
    "                        mdoi['terminal_group_2'].append(mmoi['data'][target][j]['tg-2'])\n",
    "                        mdoi['terminal_group_3'].append(mmoi['data'][target][j]['tg-3'])\n",
    "                        mdoi['frac-1'].append(mmoi['data'][target][j]['frac-1'])\n",
    "                        mdoi['frac-2'].append(mmoi['data'][target][j]['frac-2'])\n",
    "                        mdoi[f'predicted-{target}'].append(mmoi['data'][target][j][f'predicted-{target}'])\n",
    "                        mdoi[f'simulated-{target}'].append(mmoi['data'][target][j][f'simulated-{target}'])\n",
    "\n",
    "                doi['mmodels'][f'{point}_on_{tset}'][target][f'set_{i}'] = pd.DataFrame.from_dict(mdoi)\n",
    "                           \n",
    "    for point in epoints: \n",
    "        doi['emodels'][f'{point}_on_{tset}'] = dict() \n",
    "        for target in ['COF', 'intercept']:\n",
    "            doi['emodels'][f'{point}_on_{tset}'][target] = dict()\n",
    "            for i in range(5):\n",
    "                doi['emodels'][f'{point}_on_{tset}'][target][f'set_{i}'] = dict()\n",
    "                emoi = emodels[tset][target][point][f'set_{i}']\n",
    "                edoi = dict() \n",
    "                edoi['terminal_group_1'] = list()\n",
    "                edoi['terminal_group_2'] = list()\n",
    "                edoi['terminal_group_3'] = list()\n",
    "                edoi['frac-1'] = list() \n",
    "                edoi['frac-2'] = list()\n",
    "                edoi[f'predicted-{target}'] = list()\n",
    "                edoi[f'simulated-{target}'] = list()\n",
    "                for j in emoi['data'][target]:\n",
    "                    if j != 'r_square':\n",
    "                        edoi['terminal_group_1'].append(emoi['data'][target][j]['tg-1'])\n",
    "                        edoi['terminal_group_2'].append(emoi['data'][target][j]['tg-2'])\n",
    "                        edoi['terminal_group_3'].append(emoi['data'][target][j]['tg-3'])\n",
    "                        edoi['frac-1'].append(emoi['data'][target][j]['frac-1'])\n",
    "                        edoi['frac-2'].append(emoi['data'][target][j]['frac-2'])\n",
    "                        edoi[f'predicted-{target}'].append(emoi['data'][target][j][f'predicted-{target}'])\n",
    "                        edoi[f'simulated-{target}'].append(emoi['data'][target][j][f'simulated-{target}'])\n",
    "\n",
    "                doi['emodels'][f'{point}_on_{tset}'][target][f'set_{i}'] = pd.DataFrame.from_dict(edoi)\n",
    "                           \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "dca338ac",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "\"\"\" Code to rank top % simulated vs predicted\"\"\"\n",
    "refs = {'5050': m5050_test, \n",
    "        '2575': m2575_test,\n",
    "        'everything': combined_test}\n",
    "\n",
    "identifiers = ['terminal_group_1', 'terminal_group_2', 'terminal_group_3', 'frac-1', 'frac-2']\n",
    "psims = [0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5]\n",
    "pprds = [0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5]\n",
    "\n",
    "plot_data = dict()\n",
    "for tset in refs:\n",
    "    sorted_refs = {\"COF\": refs[tset].sort_values(by=\"COF\"),\n",
    "                   \"intercept\": refs[tset].sort_values(by=\"intercept\")}\n",
    "    plot_data[tset] = {\"top\": dict()}\n",
    "    for top_sim in psims:\n",
    "        for top_prd in pprds:\n",
    "            n_top_sim = round(len(refs[tset]) * top_sim)\n",
    "            n_top_prd = round(len(refs[tset]) * top_prd)\n",
    "            \n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd'] = {\"original\": dict(), \n",
    "                                                                 \"m50\": dict(),\n",
    "                                                                 \"eve\": dict()}\n",
    "            # Will worry about optimal later\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['original']['points'] = [100]\n",
    "            sorted_prd_og = dict()\n",
    "            for target in [\"COF\", \"intercept\"]:\n",
    "                # Handle original model\n",
    "                sorted_prd_og[target] = doi[\"omodels\"][f\"on_{tset}\"][target].sort_values(by=f\"predicted-{target}\")\n",
    "                top_intersect_og = pd.merge(sorted_refs[target].head(n_top_sim),\n",
    "                                         sorted_prd_og[target].head(n_top_prd),\n",
    "                                         how='inner', on=identifiers)\n",
    "                plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['original'][target] = [len(top_intersect_og)/n_top_sim*100]\n",
    "            prd_opt_og = pd.merge(sorted_prd_og[\"COF\"].head(n_top_prd), \n",
    "                                sorted_prd_og[\"intercept\"].head(n_top_prd),\n",
    "                                how='inner', on=identifiers)\n",
    "            opt_intersect_og = pd.merge(prd_opt_og, optimal, how='inner', on=identifiers)\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['original']['opt'] = [len(opt_intersect_og)/len(optimal)*100]\n",
    "            \n",
    "            \n",
    "            # Handle 5050 model\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['m50']['points'] = list()\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['m50']['COF'] = list()\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['m50']['intercept'] = list()\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['m50']['opt'] = list()\n",
    "            for point in mpoints:\n",
    "                plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['m50']['points'].append(point if isinstance(point, int) else 2680)\n",
    "                tmp_dict = {\"COF\": list(), \n",
    "                            \"intercept\": list(),\n",
    "                            \"opt\": list()}\n",
    "                \n",
    "                for i in range(5):\n",
    "                    sorted_prd_m50 = dict()\n",
    "                    for target in [\"COF\", \"intercept\"]:\n",
    "                        sorted_prd_m50[target] = doi[\"mmodels\"][f\"{point}_on_{tset}\"][target][f'set_{i}'].sort_values(by=f'predicted-{target}')\n",
    "                        top_intersect_m50 = pd.merge(sorted_refs[target].head(n_top_sim),\n",
    "                                                     sorted_prd_m50[target].head(n_top_prd),\n",
    "                                                     how='inner', on=identifiers)\n",
    "                        tmp_dict[target].append(len(top_intersect_m50)/n_top_sim*100)\n",
    "                        \n",
    "                    prd_opt_m50 = pd.merge(sorted_prd_m50[\"COF\"].head(n_top_prd),\n",
    "                                            sorted_prd_m50[\"intercept\"].head(n_top_prd),\n",
    "                                            how='inner', on=identifiers)\n",
    "                    opt_intersect_m50 = pd.merge(prd_opt_m50, optimal, how=\"inner\", on=identifiers)\n",
    "                    tmp_dict[\"opt\"].append(len(opt_intersect_m50)/len(optimal)*100)\n",
    "                \n",
    "                for target in [\"COF\", \"intercept\", \"opt\"]:\n",
    "                    plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['m50'][target].append(tmp_dict[target])\n",
    "    \n",
    "            \n",
    "            # Handle everything model\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['eve']['points'] = list()\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['eve']['COF'] = list()\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['eve']['intercept'] = list()\n",
    "            plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['eve']['opt'] = list()\n",
    "\n",
    "            for point in epoints:\n",
    "                plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['eve']['points'].append(point if isinstance(point, int) else 7816)\n",
    "                tmp_dict = {\"COF\": list(), \n",
    "                            \"intercept\": list(),\n",
    "                            \"opt\": list()}\n",
    "                \n",
    "                for i in range(5):\n",
    "                    sorted_prd_eve = dict()\n",
    "                    for target in [\"COF\", \"intercept\"]:\n",
    "                        sorted_prd_eve[target] = doi[\"emodels\"][f\"{point}_on_{tset}\"][target][f'set_{i}'].sort_values(by=f'predicted-{target}')\n",
    "                        top_intersect_eve = pd.merge(sorted_refs[target].head(n_top_sim),\n",
    "                                                     sorted_prd_eve[target].head(n_top_prd),\n",
    "                                                     how='inner', on=identifiers)\n",
    "                        tmp_dict[target].append(len(top_intersect_eve)/n_top_sim*100)\n",
    "                    prd_opt_eve = pd.merge(sorted_prd_eve[\"COF\"].head(n_top_prd), \n",
    "                                                 sorted_prd_eve[\"intercept\"].head(n_top_prd),\n",
    "                                                 how='inner', on=identifiers)\n",
    "                    opt_intersect_eve = pd.merge(prd_opt_eve, optimal, how=\"inner\", on=identifiers)\n",
    "                    tmp_dict[\"opt\"].append(len(opt_intersect_eve)/len(optimal)*100)\n",
    "                for target in [\"COF\", \"intercept\", \"opt\"]:\n",
    "                    plot_data[tset]['top'][f'top_{top_sim}sim_{top_prd}prd']['eve'][target].append(tmp_dict[target])\n",
    "                    \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "214f47de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1292382324"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COFs.COF.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "408370ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0897547562333333"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(min_COF[\"COF\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "b943b863",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050-test: 15.0% = 100\n",
      "\tCOF: 0.0972 +- 0.016 to \n",
      "\t\t0.1211 +- 0.0103\n",
      "\tintercept: 0.2161 +- 0.3768 to \n",
      "\t\t0.7794 +- 0.1345\n",
      "5050-test: 30.0% = 201\n",
      "\tCOF: 0.0972 +- 0.016 to \n",
      "\t\t0.1289 +- 0.0076\n",
      "\tintercept: 0.2161 +- 0.3768 to \n",
      "\t\t1.0021 +- 0.1709\n",
      "2575-test: 15.0% = 193\n",
      "\tCOF: 0.0898 +- 0.0119 to \n",
      "\t\t0.1218 +- 0.0138\n",
      "\tintercept: 0.0848 +- 0.462 to \n",
      "\t\t0.7058 +- 0.4097\n",
      "2575-test: 30.0% = 386\n",
      "\tCOF: 0.0898 +- 0.0119 to \n",
      "\t\t0.1295 +- 0.0107\n",
      "\tintercept: 0.0848 +- 0.462 to \n",
      "\t\t0.9511 +- 0.4361\n",
      "everything-test: 15.0% = 293\n",
      "\tCOF: 0.0898 +- 0.0119 to \n",
      "\t\t0.1216 +- 0.0104\n",
      "\tintercept: 0.0848 +- 0.462 to \n",
      "\t\t0.7295 +- 0.1159\n",
      "everything-test: 30.0% = 587\n",
      "\tCOF: 0.0898 +- 0.0119 to \n",
      "\t\t0.1292 +- 0.0154\n",
      "\tintercept: 0.0848 +- 0.462 to \n",
      "\t\t0.9669 +- 0.379\n"
     ]
    }
   ],
   "source": [
    "# Ref data\n",
    "for tset in [\"5050\", \"2575\", \"everything\"]:\n",
    "    sorted_df = {\"COF\": refs[tset].sort_values(by=\"COF\"),\n",
    "                 \"intercept\": refs[tset].sort_values(by=\"intercept\")}\n",
    "    for fraction in [0.15, 0.3]:\n",
    "        n = round(fraction*len(refs[tset]))\n",
    "        COFs = sorted_df[\"COF\"].head(n)\n",
    "        intercepts = sorted_df[\"intercept\"].head(n)\n",
    "        \n",
    "        min_COF = COFs[COFs.COF == COFs.COF.min()]\n",
    "        max_COF = COFs[COFs.COF == COFs.COF.max()]\n",
    "        min_intercept = intercepts[intercepts.intercept == intercepts.intercept.min()]\n",
    "        max_intercept = intercepts[intercepts.intercept == intercepts.intercept.max()]\n",
    "        \n",
    "        print(f\"{tset}-test: {fraction*100}% = {n}\")\n",
    "        print(f\"\\tCOF: {round(float(min_COF['COF']), 4)} +- {round(float(min_COF['COF-std']), 4)} to \\n\"\n",
    "              f\"\\t\\t{round(float(max_COF['COF']), 4)} +- {round(float(max_COF['COF-std']), 4)}\")\n",
    "        print(f\"\\tintercept: {round(float(min_intercept['intercept']), 4)} +- {round(float(min_intercept['intercept-std']), 4)} to \\n\"\n",
    "              f\"\\t\\t{round(float(max_intercept['intercept']), 4)} +- {round(float(max_intercept['intercept-std']), 4)}\")        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b393c995",
   "metadata": {},
   "source": [
    "# Top 15% of 5050-test/2575-test predicted by top 15%/30% m50 models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "2b488576",
   "metadata": {},
   "outputs": [],
   "source": [
    "markersize=10\n",
    "elinewidth=1\n",
    "alpha=0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "f9a1a362",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1008 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "top_sim1 = 0.15\n",
    "top_prd1 = 0.15\n",
    "\n",
    "top_sim2 = 0.15 \n",
    "top_prd2 = 0.30\n",
    "\n",
    "fig1, ax = plt.subplots(2, 2, figsize=(20, 14))\n",
    "\n",
    "markers = {'COF': ['o', '--', 'dodgerblue'], 'intercept': ['s', '--', 'firebrick'], 'opt': ['s', '--', 'indigo']}\n",
    "\n",
    "for target in ['COF', 'intercept']:\n",
    "    print(target)\n",
    "    ax[0, 0].errorbar(x=plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "    ax[1, 0].errorbar(x=plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "\n",
    "    ax[0, 0].axhline(plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "    ax[1, 0].axhline(plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "\n",
    "    ax[0, 1].errorbar(x=plot_data['5050']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['5050']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['5050']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "    ax[1, 1].errorbar(x=plot_data['2575']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['2575']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['2575']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "\n",
    "    ax[0, 1].axhline(plot_data['5050']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "    ax[1, 1].axhline(plot_data['2575']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "\n",
    "    \n",
    "#ax.legend()\n",
    "leg1_ele = [Line2D([0], [0], color='dodgerblue', marker='o', markersize=12, linestyle='', label='COF'),\n",
    "                   Line2D([0], [0], color='firebrick', marker='s', markersize=12, linestyle='', label=r'$\\mathit{F_0}$')]\n",
    "\n",
    "for i in [0, 1]:\n",
    "    for j in [0, 1]:\n",
    "        legend = ax[i, j].legend(handles=leg1_ele, loc=4, prop={'size': 24})# title='Properties')\n",
    "        ax[i, j].set_ylim(40, 100)\n",
    "        ax[i, j].set_xlim(0, 3000)\n",
    "        ax[i, j].set_xlabel('N', style='italic')\n",
    "        ax[i, j].set_ylabel('Overlapped (%)')\n",
    "        ax[i, j].add_artist(legend)\n",
    "\n",
    "plt.savefig(fname=f'./plots/top_v2/train50({top_prd1}-{top_prd2})-test50({top_sim1})test25({top_sim1}).pdf', dpi=500, bbox_inches='tight')\n",
    "\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "653ada0f",
   "metadata": {},
   "source": [
    "## Top 15% of test-5050/2575 predicted by m50 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "4d1aed67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "top_sim1 = 0.15\n",
    "top_prd1 = 0.15\n",
    "\n",
    "\n",
    "fig1, ax = plt.subplots(1, 2, figsize=(20, 7))\n",
    "\n",
    "markers = {'COF': ['o', '--', 'dodgerblue'], 'intercept': ['s', '--', 'firebrick'], 'opt': ['s', '--', 'indigo']}\n",
    "\n",
    "for target in ['COF', 'intercept']:\n",
    "    ax[0].errorbar(x=plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "    ax[1].errorbar(x=plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "\n",
    "    ax[0].axhline(plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "    ax[1].axhline(plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "\n",
    "\n",
    "#ax.legend()\n",
    "leg1_ele = [Line2D([0], [0], color='dodgerblue', marker='o', markersize=12, linestyle='', label='COF'),\n",
    "                   Line2D([0], [0], color='firebrick', marker='s', markersize=12, linestyle='', label=r'$\\mathit{F_0}$')]\n",
    "\n",
    "for i in [0, 1]:\n",
    "    legend = ax[i].legend(handles=leg1_ele, loc=4, prop={'size': 24})# title='Properties')\n",
    "    ax[i].set_ylim(40, 100)\n",
    "    ax[i].set_xlim(0, 3000)\n",
    "    ax[i].set_xlabel('N', style='italic')\n",
    "    ax[i].set_ylabel('Overlapped (%)')\n",
    "    ax[i].add_artist(legend)\n",
    "\n",
    "plt.savefig(fname=f'./plots/top_v2/train50({top_prd1})-test50({top_sim1})test25({top_sim1}).pdf', dpi=500, bbox_inches='tight')\n",
    "\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07be0e43",
   "metadata": {},
   "source": [
    "## Top 30% of test-5050/2575predicted by m50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "7443e43f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "top_sim1 = 0.15\n",
    "top_prd1 = 0.30\n",
    "\n",
    "\n",
    "fig1, ax = plt.subplots(1, 2, figsize=(20, 7))\n",
    "\n",
    "markers = {'COF': ['o', '--', 'dodgerblue'], 'intercept': ['s', '--', 'firebrick'], 'opt': ['s', '--', 'indigo']}\n",
    "\n",
    "for target in ['COF', 'intercept']:\n",
    "    ax[0].errorbar(x=plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "    ax[1].errorbar(x=plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['m50'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "\n",
    "    ax[0].axhline(plot_data['5050']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "    ax[1].axhline(plot_data['2575']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "\n",
    "\n",
    "#ax.legend()\n",
    "leg1_ele = [Line2D([0], [0], color='dodgerblue', marker='o', markersize=12, linestyle='', label='COF'),\n",
    "                   Line2D([0], [0], color='firebrick', marker='s', markersize=12, linestyle='', label=r'$\\mathit{F_0}$')]\n",
    "\n",
    "for i in [0, 1]:\n",
    "    legend = ax[i].legend(handles=leg1_ele, loc=4, prop={'size': 24})# title='Properties')\n",
    "    ax[i].set_ylim(40, 100)\n",
    "    ax[i].set_xlim(0, 3000)\n",
    "    ax[i].set_xlabel('N', style='italic')\n",
    "    ax[i].set_ylabel('Overlapped (%)')\n",
    "    ax[i].add_artist(legend)\n",
    "\n",
    "plt.savefig(fname=f'./plots/top_v2/train50({top_prd1})-test50({top_sim1})test25({top_sim1}).pdf', dpi=500, bbox_inches='tight')\n",
    "\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "8e34ccfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top 0.15\n",
      "tset 5050\n",
      "COF\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[51.0, 60.0, 62.2, 68.6, 74.4, 76.2, 79.0, 83.0, 84.2]\n",
      "[8.555699854482974, 2.898275349237885, 1.5999999999999999, 1.4966629547095764, 0.8, 0.9797958971132712, 1.4142135623730951, 0.8944271909999159, 0.4]\n",
      "intercept\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[60.8, 61.0, 65.0, 65.8, 67.6, 69.2, 71.2, 71.2, 72.4]\n",
      "[2.9933259094191564, 2.366431913239848, 3.8987177379235853, 1.4696938456699067, 1.019803902718557, 1.7204650534085253, 1.16619037896906, 1.16619037896906, 0.8]\n",
      "tset 2575\n",
      "COF\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[49.119170984455955, 55.12953367875648, 56.6839378238342, 61.34715025906736, 62.59067357512953, 61.554404145077726, 62.69430051813472, 62.69430051813472, 61.865284974093264]\n",
      "[6.349211888928656, 2.03594639423715, 0.6217616580310903, 1.3351397644274756, 1.3669332599246553, 1.5159314858370767, 1.086848547326583, 0.8670052088436022, 0.41450777202072686]\n",
      "intercept\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[56.0621761658031, 57.2020725388601, 59.79274611398963, 62.27979274611399, 61.968911917098445, 61.968911917098445, 63.212435233160626, 63.73056994818653, 63.83419689119172]\n",
      "[3.458719019332361, 1.625325092368715, 0.9033987447752703, 2.030665071737353, 1.4873264346536093, 1.1160963330848734, 0.7327531411259566, 0.5675881424923995, 0.38773651676413734]\n",
      "top 0.3\n",
      "tset 5050\n",
      "COF\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[78.0, 86.0, 87.6, 90.8, 91.6, 92.4, 94.4, 96.2, 95.8]\n",
      "[7.536577472566709, 3.687817782917155, 2.727636339397171, 2.785677655436824, 2.0591260281974, 1.3564659966250536, 0.4898979485566356, 1.16619037896906, 0.4]\n",
      "intercept\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[92.4, 93.0, 93.0, 95.8, 97.0, 97.0, 96.6, 98.6, 98.6]\n",
      "[2.0591260281974, 1.4142135623730951, 1.0954451150103321, 1.5999999999999999, 0.6324555320336759, 0.6324555320336759, 0.4898979485566356, 0.4898979485566356, 0.4898979485566356]\n",
      "tset 2575\n",
      "COF\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[72.84974093264249, 79.06735751295336, 80.31088082901555, 82.279792746114, 84.14507772020725, 84.55958549222798, 85.18134715025907, 85.69948186528498, 86.11398963730569]\n",
      "[6.680522885507231, 1.7524906243821532, 1.6384858342841349, 1.405664245207309, 1.5578545469816465, 0.9497566207162396, 0.9609967352845267, 0.7754730335282747, 0.6042437196730844]\n",
      "intercept\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 2680]\n",
      "[85.07772020725389, 87.87564766839378, 88.29015544041451, 88.39378238341968, 88.49740932642486, 89.63730569948186, 89.11917098445595, 89.63730569948186, 89.43005181347148]\n",
      "[2.0569360871791895, 2.3991371819254352, 1.1160963330848697, 1.2521291164346708, 1.1064329794851082, 0.9268675554403258, 1.2261305249947374, 0.4634337777201653, 0.2538331339671696]\n"
     ]
    }
   ],
   "source": [
    "for prd in [\"0.15\", \"0.3\"]:\n",
    "    print(\"top\", prd)\n",
    "    for tset in [\"5050\", \"2575\"]:\n",
    "        print(\"tset\", tset)\n",
    "        for target in [\"COF\", \"intercept\"]:\n",
    "            print(target)\n",
    "            print(plot_data[tset]['top'][f'top_0.15sim_{prd}prd']['m50'][\"points\"])\n",
    "            print([np.mean(vals) for vals in plot_data[tset]['top'][f'top_0.15sim_{prd}prd']['m50'][target]])\n",
    "            print([np.std(vals) for vals in plot_data[tset]['top'][f'top_0.15sim_{prd}prd']['m50'][target]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88927657",
   "metadata": {},
   "source": [
    "# Top 15% of combined predicted by m50 amd eve models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "6cdf6a6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "top_sim1 = 0.15\n",
    "top_prd1 = 0.15\n",
    "\n",
    "top_sim2 = 0.15\n",
    "top_prd2 = 0.3\n",
    "\n",
    "fig1, ax = plt.subplots(1, 2, figsize=(20, 7))\n",
    "\n",
    "markers = {'COF': ['o', '--', 'dodgerblue'], 'intercept': ['s', '--', 'firebrick'], 'opt': ['P', '--', 'indigo']}\n",
    "\n",
    "for target in ['COF', 'intercept', 'opt']:\n",
    "    ax[0].errorbar(x=plot_data['everything']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['eve']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['everything']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['eve'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['everything']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['eve'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "\n",
    "\n",
    "    ax[0].axhline(plot_data['everything']['top'][f'top_{top_sim1}sim_{top_prd1}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "\n",
    "\n",
    "    ax[1].errorbar(x=plot_data['everything']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['eve']['points'], \n",
    "                      y=[np.mean(vals) for vals in plot_data['everything']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['eve'][target]],\n",
    "                      yerr=[np.std(vals) for vals in plot_data['everything']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['eve'][target]],\n",
    "                      fmt=markers[target][0],\n",
    "                      color=markers[target][2],\n",
    "                      markersize=markersize,\n",
    "                      elinewidth=elinewidth)\n",
    "\n",
    "\n",
    "    ax[1].axhline(plot_data['everything']['top'][f'top_{top_sim2}sim_{top_prd2}prd']['original'][target],\n",
    "                linestyle=markers[target][1],\n",
    "                linewidth=2,\n",
    "                color=markers[target][2],\n",
    "                alpha=alpha)\n",
    "\n",
    "\n",
    "ax[0].set_xlabel('N', style='italic')\n",
    "ax[0].set_ylabel('Overlapped (%)')\n",
    "ax[1].set_xlabel('N', style='italic')\n",
    "ax[1].set_ylabel('Overlapped (%)')\n",
    "\n",
    "ax[0].set_ylim(0, 100)\n",
    "ax[1].set_ylim(0, 100)\n",
    "ax[0].set_xlim(0, 8000)\n",
    "ax[1].set_xlim(0, 8000)\n",
    "\n",
    "#ax.legend()\n",
    "leg1_ele = [Line2D([0], [0], color='dodgerblue', marker='o', markersize=12, linestyle='', label='COF'),\n",
    "            Line2D([0], [0], color='firebrick', marker='s', markersize=12, linestyle='', label=r'$\\mathit{F_0}$'),\n",
    "            Line2D([0], [0], color='indigo', marker='P', markersize=12, linestyle='', label='Most-favorable')]\n",
    "\n",
    "legend1a = ax[0].legend(handles=leg1_ele, loc=4, prop={'size': 24})#, title='Properties')\n",
    "ax[0].add_artist(legend1a)\n",
    "\n",
    "legend1b = ax[1].legend(handles=leg1_ele, loc=4, prop={'size': 24})#, title='Properties')\n",
    "ax[1].add_artist(legend1b)\n",
    "\n",
    "\n",
    "plt.savefig(fname=f'./plots/top_v2/traineve({top_prd1}-{top_prd2})-traineve({top_sim1}).pdf', dpi=500, bbox_inches='tight')\n",
    "\n",
    "\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "25d6ca27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top 0.15\n",
      "tset everything\n",
      "COF\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 7816]\n",
      "[54.19795221843003, 56.72354948805461, 58.63481228668942, 62.86689419795223, 66.48464163822526, 68.87372013651878, 70.37542662116041, 72.49146757679182, 76.45051194539249, 80.13651877133105, 84.16382252559727]\n",
      "[5.354773694868311, 3.8997561384534323, 1.9354876284993632, 1.5625287566224697, 0.9259153560580567, 0.33440133007279116, 0.7288108021864363, 0.27303754266211583, 0.6475653911607656, 0.6617992979407962, 0.2730375426621208]\n",
      "intercept\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 7816]\n",
      "[54.19795221843003, 58.63481228668942, 60.750853242320815, 61.22866894197953, 63.34470989761091, 63.48122866894198, 63.68600682593857, 63.68600682593857, 64.9146757679181, 63.344709897610926, 63.617747440273035]\n",
      "[4.275893450748348, 1.5171406669551444, 2.211856893654561, 1.5803190310976405, 2.5042916488524405, 1.7799870048334878, 1.8643686394194736, 1.4735176208138503, 0.7901595155488224, 1.0921501706484666, 0.34805593949438796]\n",
      "opt\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 7816]\n",
      "[7.272727272727272, 26.363636363636363, 34.54545454545455, 49.09090909090909, 62.72727272727271, 62.72727272727273, 62.72727272727273, 66.36363636363636, 70.0, 68.18181818181817, 77.27272727272727]\n",
      "[10.601730717900546, 19.155734096095884, 11.712817024295568, 17.10444338384253, 15.587661999529312, 17.814470856604927, 14.488524955008387, 7.385489458759962, 6.803013430498074, 8.624393618641033, 0.0]\n",
      "top 0.3\n",
      "tset everything\n",
      "COF\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 7816]\n",
      "[79.65870307167236, 80.61433447098975, 82.52559726962457, 84.91467576791808, 86.34812286689422, 88.87372013651877, 89.35153583617748, 91.19453924914674, 93.37883959044368, 96.04095563139931, 97.47440273037543]\n",
      "[2.819368795640053, 1.2095593956770898, 1.7187274146094413, 1.044167818483168, 0.6105305058019931, 0.9055630826908949, 0.9507432271115417, 1.0662456895435684, 1.0261635753155511, 0.6330115013990275, 0.16720066503639036]\n",
      "intercept\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 7816]\n",
      "[82.5938566552901, 86.41638225255971, 87.71331058020478, 88.66894197952219, 90.1023890784983, 90.71672354948805, 90.98976109215018, 91.05802047781569, 91.80887372013652, 92.08191126279863, 92.08191126279863]\n",
      "[3.3300507624984244, 1.0216129383683186, 1.5415139645919764, 1.0878755938914135, 0.30526525290099416, 0.5460750853242303, 0.4629576780290241, 0.5460750853242303, 0.30526525290100054, 0.8191126279863513, 0.1365187713310604]\n",
      "opt\n",
      "[100, 200, 300, 500, 1000, 1500, 2000, 2500, 4000, 6000, 7816]\n",
      "[56.36363636363636, 70.0, 68.18181818181819, 80.9090909090909, 85.45454545454545, 85.45454545454547, 86.36363636363637, 86.36363636363635, 89.0909090909091, 90.9090909090909, 89.09090909090908]\n",
      "[28.69042516010818, 8.43056226863246, 7.041787902195308, 6.680426571226851, 4.453617714151227, 6.680426571226846, 7.606000241218866, 5.749595745760689, 4.635472285084347, 0.0, 2.226808857075617]\n"
     ]
    }
   ],
   "source": [
    "for prd in [\"0.15\", \"0.3\"]:\n",
    "    print(\"top\", prd)\n",
    "    for tset in [\"everything\"]:\n",
    "        print(\"tset\", tset)\n",
    "        for target in [\"COF\", \"intercept\", \"opt\"]:\n",
    "            print(target)\n",
    "            print(plot_data[tset]['top'][f'top_0.15sim_{prd}prd']['eve'][\"points\"])\n",
    "            print([np.mean(vals) for vals in plot_data[tset]['top'][f'top_0.15sim_{prd}prd']['eve'][target]])\n",
    "            print([np.std(vals) for vals in plot_data[tset]['top'][f'top_0.15sim_{prd}prd']['eve'][target]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "11decbf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['original', 'm50', 'eve'])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_data[tset]['top'][f'top_0.15sim_{prd}prd'].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b54db727",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}