analyze_flow_importance.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib\n",
    "matplotlib.use('Agg')\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.backends.backend_pdf import PdfPages\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "from scripts.parsing_utils import *\n",
    "from utils.utils import *\n",
    "from scripts.parse_results import *\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "#RES_DIR = \"/home/pari/learned-cardinalities/all_results/inl_fixed_scan_ops/nested_loop_index7/test_diff/subq_imp\"\n",
    "#RES_DIR2 = \"/home/pari/learned-cardinalities/all_results/inl_fixed_scan_ops/nested_loop_index7/test_diff/subq_imp2\"\n",
    "\n",
    "#RES_DIR = \"/home/pari/learned-cardinalities/debug/\"\n",
    "RES_DIR = \"/home/pari/learned-cardinalities/all_results/inl_fixed_scan_ops/nested_loop_index7/test_diff/final_results3_lc\"\n",
    "\n",
    "\n",
    "HIGH_QUANTILE = 0.80\n",
    "LOW_QUANTILE = 0.20\n",
    "\n",
    "COLORS = {}\n",
    "COLORS[\"Flow Loss\"] = \"blue\"\n",
    "COLORS[\"Q-Error\"] = \"green\"\n",
    "\n",
    "ALG_KEY = {}\n",
    "ALG_KEY[\"flow_loss2\"] = \"Flow Loss\"\n",
    "ALG_KEY[\"mse\"] = \"Q-Error\"\n",
    "\n",
    "SAVE_DIR =\"./figures/results1/\"\n",
    "make_dir(SAVE_DIR)\n",
    "FN_TMP = SAVE_DIR + \"Flow-Importance-{TYPE}-{PART}.png\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "skipping obj:  subq_summary.pkl\n"
     ]
    }
   ],
   "source": [
    "df = get_all_objects(RES_DIR, \"subq_summary.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['loss', 'num_tables', 'template', 'subq_imp', 'subq_id', 'samples_type',\n",
      "       'epoch', 'alg', 'sample_bitmap', 'hidden_layer_size', 'flow_features',\n",
      "       'alg_name', 'partition'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(df.keys())\n",
    "df.head()\n",
    "df = df[df.partition == 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('ggplot') \n",
    "plt.figure(figsize=(5,4))\n",
    "sns.distplot(df[\"subq_imp\"], kde=False, color=\"blue\")\n",
    "FN = FN_TMP.format(TYPE = \"Distribution\", PART=\"2\")\n",
    "plt.savefig(FN)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3.8/site-packages/pandas/core/indexing.py:845: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self.obj[key] = _infer_fill_value(value)\n",
      "/usr/lib/python3.8/site-packages/pandas/core/indexing.py:966: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self.obj[item] = s\n"
     ]
    }
   ],
   "source": [
    "dfh = df[df.subq_imp >= df.subq_imp.quantile(HIGH_QUANTILE)]\n",
    "dfl = df[df.subq_imp <= df.subq_imp.quantile(LOW_QUANTILE)]\n",
    "dfm = df[df.subq_imp > df.subq_imp.quantile(LOW_QUANTILE)]\n",
    "dfm = dfm[dfm.subq_imp < df.subq_imp.quantile(HIGH_QUANTILE)]\n",
    "\n",
    "assert len(df) == len(dfh) + len(dfl) + len(dfm)\n",
    "dfh.loc[:,\"subq_imp_group\"] = \"high\"\n",
    "dfm.loc[:,\"subq_imp_group\"] = \"mid\"\n",
    "dfl.loc[:,\"subq_imp_group\"] = \"low\"\n",
    "df_groups = pd.concat([dfl, dfm, dfh], ignore_index = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_groups[\"alg\"] = df_groups.apply(lambda x: ALG_KEY[x[\"alg\"]] ,axis=1)\n",
    "\n",
    "plt.style.use('ggplot')   \n",
    "plt.figure(figsize=(5,4))\n",
    "\n",
    "ORDER = [\"Q-Error\", \"Flow Loss\"]\n",
    "sns.barplot(x = \"subq_imp_group\", y = \"loss\", hue = \"alg\", data = df_groups, palette=COLORS, hue_order=ORDER)\n",
    "plt.xlabel(\"Subquery Importance (by Flows)\")\n",
    "plt.title(\"Q-Error Performance (Test-Set)\")\n",
    "\n",
    "plt.ylabel(\"Log Normalized Q-Error\")\n",
    "plt.legend(title=\"Loss Function\")\n",
    "\n",
    "# legend = plt.legend(handles=[one, two, three], title=\"title\",\n",
    "#                     loc=4, fontsize='small', fancybox=True)\n",
    "\n",
    "FN = FN_TMP.format(TYPE = \"Q-Errors\", PART=\"2\")\n",
    "plt.savefig(FN)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # TODO: reload stuff\n",
    "# df = get_all_objects(RES_DIR, \"subq_summary.pkl\")\n",
    "# print(len(df))\n",
    "# dfh = df[df.subq_imp > df.subq_imp.quantile(HIGH_QUANTILE)]\n",
    "# dfl = df[df.subq_imp < df.subq_imp.quantile(LOW_QUANTILE)]\n",
    "# dfm = df[df.subq_imp > df.subq_imp.quantile(LOW_QUANTILE)]\n",
    "# dfm = dfm[dfm.subq_imp < df.subq_imp.quantile(HIGH_QUANTILE)]\n",
    "\n",
    "# assert len(df) == len(dfh) + len(dfl) + len(dfm)\n",
    "# dfh.loc[:,\"subq_imp_group\"] = \"high\"\n",
    "# dfm.loc[:,\"subq_imp_group\"] = \"mid\"\n",
    "# dfl.loc[:,\"subq_imp_group\"] = \"low\"\n",
    "# df_groups = pd.concat([dfl, dfm, dfh], ignore_index = True)\n",
    "#test_subq_ids = set(df[df[\"samples_type\"] == \"test\"][\"subq_id\"])\n",
    "#df_groups = df_groups[df_groups[\"subq_id\"].isin(test_subq_ids)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "subq_imp_group  samples_type\n",
       "high            test            2271\n",
       "                train           2011\n",
       "low             test            3520\n",
       "                train           2286\n",
       "mid             test            2110\n",
       "                train           1860\n",
       "Name: subq_id, dtype: int64"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_groups.groupby([\"subq_imp_group\", \"samples_type\"])[\"subq_id\"].nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df2 = df_groups.groupby([\"subq_imp_group\", \"samples_type\"])[\"subq_id\"].nunique().reset_index()\n",
    "# print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ORDER = [\"low\", \"mid\", \"high\"]\n",
    "\n",
    "# #df2 = df2.rename(columns={\"samples_type\":\"Subquery Kind\"})\n",
    "# #df2[\"Subquery Kind\"] = df2.apply(, axis=1)\n",
    "# plt.style.use('ggplot')\n",
    "# plt.figure(figsize=(5,4))\n",
    "\n",
    "\n",
    "# HUE_ORDER=[\"train\", \"test\"]\n",
    "# TRAIN_COLORS = {}\n",
    "# TRAIN_COLORS[\"train\"] = \"orange\"\n",
    "# TRAIN_COLORS[\"test\"] = \"red\"\n",
    "\n",
    "# sns.barplot(data=df2, x=\"subq_imp_group\", y=\"subq_id\", hue=\"samples_type\", order=ORDER, hue_order=HUE_ORDER, \n",
    "#             palette=TRAIN_COLORS)\n",
    "# plt.xlabel(\"Subquery Importance (by Flows)\")\n",
    "# plt.title(\"Unique Subquery Combinations\")\n",
    "# plt.ylabel(\"Number of Subqueries\")\n",
    "\n",
    "# FN = FN_TMP.format(TYPE = \"Subquery-Grouping\", PART=\"2\")\n",
    "\n",
    "# plt.legend(title=\"Subquery Kind\")\n",
    "\n",
    "# plt.savefig(FN)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>subq_imp_group</th>\n",
       "      <th>samples_type</th>\n",
       "      <th>subq_id</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>high</td>\n",
       "      <td>test</td>\n",
       "      <td>690</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>high</td>\n",
       "      <td>train</td>\n",
       "      <td>441</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>low</td>\n",
       "      <td>test</td>\n",
       "      <td>3093</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>low</td>\n",
       "      <td>train</td>\n",
       "      <td>919</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>mid</td>\n",
       "      <td>test</td>\n",
       "      <td>3461</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>mid</td>\n",
       "      <td>train</td>\n",
       "      <td>1322</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  subq_imp_group samples_type  subq_id\n",
       "0           high         test      690\n",
       "1           high        train      441\n",
       "2            low         test     3093\n",
       "3            low        train      919\n",
       "4            mid         test     3461\n",
       "5            mid        train     1322"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4601\n"
     ]
    }
   ],
   "source": [
    "print(len(set(df[\"subq_id\"])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "samples_type\n",
       "test     3566\n",
       "train    2377\n",
       "Name: subq_id, dtype: int64"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_groups.groupby([\"samples_type\"])[\"subq_id\"].nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "samples_type\n",
       "test     3286820\n",
       "train    3521146\n",
       "Name: subq_id, dtype: int64"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_groups.groupby([\"samples_type\"])[\"subq_id\"].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_subq_ids(df, samples_type):\n",
    "    df = df[df.samples_type == samples_type]\n",
    "    return df.subq_id.values\n",
    "\n",
    "def get_subq_overlap(df, st1, st2):\n",
    "    a = get_subq_ids(df, st1)\n",
    "    b = get_subq_ids(df, st2)\n",
    "    common = np.intersect1d(a, b)\n",
    "    return len(common)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4601\n"
     ]
    }
   ],
   "source": [
    "print(len(set(df[\"subq_id\"])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1342"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_subq_overlap(df, \"train\", \"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_subq_overlap(df, \"train\", \"job\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3335904\n",
      "136158\n",
      "3335904\n",
      "[1249, 959, 1084]\n",
      "[4557, 3011, 3198]\n",
      "[0.27408383 0.31849884 0.33896185]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 360x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ORDER = [\"low\", \"mid\", \"high\"]\n",
    "\n",
    "#df2 = df2.rename(columns={\"samples_type\":\"Subquery Kind\"})\n",
    "#df2[\"Subquery Kind\"] = df2.apply(, axis=1)\n",
    "plt.style.use('ggplot')\n",
    "plt.figure(figsize=(5,4))\n",
    "\n",
    "y_overlap = []\n",
    "y_total = []\n",
    "for grp in ORDER:\n",
    "    tmp = df_groups[df_groups.subq_imp_group == grp]\n",
    "    print(len(tmp))\n",
    "    y_total.append(len(set(tmp[\"subq_id\"])))\n",
    "    y_overlap.append(get_subq_overlap(tmp, \"train\", \"test\"))\n",
    "\n",
    "print(y_overlap)\n",
    "print(y_total)\n",
    "print(np.array(y_overlap) / np.array(y_total))\n",
    "# sns.barplot(data=df2, x=\"subq_imp_group\", y=\"subq_id\", hue=\"samples_type\", order=ORDER, hue_order=HUE_ORDER, \n",
    "#             palette=TRAIN_COLORS)\n",
    "# plt.xlabel(\"Subquery Importance (by Flows)\")\n",
    "# plt.title(\"Unique Subquery Combinations\")\n",
    "# plt.ylabel(\"Number of Subqueries\")\n",
    "\n",
    "# FN = FN_TMP.format(TYPE = \"Subquery-Grouping\", PART=\"2\")\n",
    "\n",
    "# plt.legend(title=\"Subquery Kind\")\n",
    "\n",
    "# plt.savefig(FN)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'test', 'train'}"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(df[\"samples_type\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}