analysis_coefficient_separate_days.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from distutils.dir_util import copy_tree\n",
    "import itertools\n",
    "import scipy\n",
    "from scipy import stats\n",
    "import dask.dataframe as dd\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import time, pytz\n",
    "from datetime import datetime\n",
    "from matplotlib.ticker import MultipleLocator, FixedLocator, LogLocator, NullFormatter, ScalarFormatter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "store_location = \"./SurfCoefficients50days/\"\n",
    "\n",
    "combination_tuples_pearson = dict()\n",
    "combination_tuples_spearman = dict()\n",
    "combination_tuples_kendall = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# WARNING: LOADING ALL RAW DATA TAKES A LONG TIME, USE THE DF CELL AS THAT IS PROCESSED AND STORED IN PARQUET IF AVAILABLE.\n",
    "folders = next(os.walk(store_location))[1]\n",
    "\n",
    "for folder in folders:\n",
    "    start_date = folder.split(\"_\")[0]\n",
    "    \n",
    "    for combination_file in next(os.walk(os.path.join(store_location, folder)))[2]:\n",
    "        with open(os.path.join(store_location, folder, combination_file)) as coef_file:\n",
    "            pc, sc, kc = coef_file.readline().split(\"|\")\n",
    "            pv_pc, pv_sc, pv_kc = coef_file.readline().split(\"|\")\n",
    "            combination_tuples_pearson.setdefault(combination_file, []).append((pc, start_date, pv_pc))\n",
    "            combination_tuples_spearman.setdefault(combination_file, []).append((sc, start_date, pv_sc))\n",
    "            combination_tuples_kendall.setdefault(combination_file, []).append((kc, start_date, pv_kc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node_netstat_TcpExt_TCPFastRetrans+node_netstat_TcpExt_TCPAutoCorking_correlations.csv 50\n",
      "node_memory_Slab+node_memory_Active_file_correlations.csv 50\n",
      "nvidia_gpu_fanspeed_percent+node_memory_MemFree_correlations.csv 50\n",
      "node_memory_Buffers+node_sockstat_sockets_used_correlations.csv 50\n"
     ]
    }
   ],
   "source": [
    "threshold = 0.7\n",
    "\n",
    "for combination, values in combination_tuples_pearson.items():\n",
    "    num_values_above_threshold = sum([1 if abs(float(v[0])) >= threshold else 0 for v in values])\n",
    "    if num_values_above_threshold == len(next(os.walk(store_location))[1]):\n",
    "        print(combination)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Execute this cell to generate the plots\n",
    "cache_location = \"./cache/correlation_coefficients_50_separate_days.parquet\"\n",
    "if not os.path.exists(cache_location):\n",
    "    tuple_list = [val for i in combination_tuples_spearman.keys() for val in combination_tuples_spearman[i]]\n",
    "    df = pd.DataFrame(tuple_list, columns=['coef', 'start_date', 'pval'])\n",
    "    df = df.replace(\"nan\", np.nan).dropna().reset_index(drop=True)\n",
    "    df['start_date'] = pd.to_datetime(df['start_date'], unit='s')\n",
    "    df['coef'] = df['coef'].astype(np.float)\n",
    "    df.to_parquet(cache_location, engine='pyarrow')\n",
    "else:\n",
    "    df = pd.read_parquet(cache_location, engine='pyarrow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(11, 3))\n",
    "ax.tick_params(axis='both', which='major', labelsize=14)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=14)\n",
    "ax.set_xlabel(\"Day\", fontsize=18)\n",
    "ax.set_ylabel(\"Number of Pairs\", fontsize=20)\n",
    "\n",
    "# These two must match in size for the zip() function later\n",
    "thresholds = [0.9,\n",
    "#               0.7,\n",
    "#               0.5,\n",
    "             ]\n",
    "colors = [\"lightcoral\", \"steelblue\", \"yellowgreen\"]\n",
    "linestyles = ['solid', 'dashed', 'dotted']\n",
    "\n",
    "bottom = None\n",
    "for threshold, color, linestyle in zip(thresholds, colors, linestyles):\n",
    "    count_df = df[df['coef'].abs() >= threshold].groupby('start_date').count().rename(columns={'coef': 'count'})\n",
    "    data = count_df.copy()\n",
    "    if bottom is not None:\n",
    "        data['count'] -= bottom['count']  # As we expect more matches for a lower threshold, subtract the previous one to get the correct stack\n",
    "    \n",
    "    ax.bar(x=range(len(data)), height=data['count'], bottom=bottom['count'] if bottom is not None else 0, label=f\"Number of correlated pairs present on each day\", color=color)\n",
    "    bottom = count_df\n",
    "    \n",
    "    num_coef_corr_all_days = 0\n",
    "    for combination, values in combination_tuples_spearman.items():\n",
    "        num_values_above_threshold = sum([1 if abs(float(v[0])) >= threshold else 0 for v in values])\n",
    "        if num_values_above_threshold == len(next(os.walk(store_location))[1]):\n",
    "            num_coef_corr_all_days += 1\n",
    "    \n",
    "    ax.hlines(num_coef_corr_all_days, xmin=-.8, xmax=len(data) - .2, color=\"black\", linestyle=linestyle, label=f\"{num_coef_corr_all_days} correlated pairs are present on all days\")\n",
    "\n",
    "def get_converted_xticks(ax):\n",
    "    \"\"\"\n",
    "    :param ax:\n",
    "    :return list of day and month strings\n",
    "    \"\"\"\n",
    "    # return [pd.to_datetime(start + tick, unit='s').date().strftime(\"%d\\n%b\") for tick in ax.get_xticks()]\n",
    "    return [int((tick) / 3600) for tick in ax.get_xticks()]  # Get the hour number\n",
    "\n",
    "ax.legend(prop={\"size\": 14})\n",
    "\n",
    "# you MUST use xycoords = data with this function\n",
    "def my_annotate(ax, s, xy_arr=[], *args, **kwargs):  # modified from https://stackoverflow.com/a/14545981\n",
    "    ans = []\n",
    "    kwargs_copy = kwargs.copy()\n",
    "    kwargs_copy.pop('arrowprops', None)\n",
    "    an = ax.annotate(s, xy_arr[0], *args, **kwargs_copy)\n",
    "    ans.append(an)\n",
    "    d = {}\n",
    "    xytext = kwargs['xytext']\n",
    "    if 'arrowprops' in kwargs:\n",
    "        d['arrowprops'] = kwargs['arrowprops']\n",
    "    if 'ha' in kwargs:\n",
    "        d['ha'] = kwargs['ha']\n",
    "    if 'va' in kwargs:\n",
    "        d['va'] = kwargs['va']\n",
    "    for xy in xy_arr[0:]:\n",
    "        # Hack to make the arrows start at the same position\n",
    "        an = ax.annotate('', xy, alpha=0.0, xytext=xytext, xycoords='data', **d)\n",
    "        ans.append(an)\n",
    "    return ans\n",
    "\n",
    "my_annotate(ax,\n",
    "            s='The number of correlating pairs differs significantly per day',\n",
    "            xy_arr=[[4, 200], [5, 150], [7, 118]],\n",
    "            xytext=(10, 130), xycoords='data', # xytext based on the first point\n",
    "            ha='left', va='center', \n",
    "            fontsize=14,\n",
    "            arrowprops=dict(arrowstyle=\"-|>\",\n",
    "                            connectionstyle=\"arc\",\n",
    "                            color=\"black\")\n",
    "           )\n",
    "ax.set_yticks( [0,40,80,120,160,200])\n",
    "ax.set_yticklabels(['0', '40', '', '', '', '200'])\n",
    "\n",
    "date_time = datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")\n",
    "fig.savefig(f\"spearman_correlations_50_days_{date_time}.pdf\", bbox_inches = \"tight\")\n",
    "# fig.savefig(f\"spearman_correlations_50_days_{date_time}.png\", bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0.8\n",
    "\n",
    "unique_pairs = set()\n",
    "for combination, values in combination_tuples_spearman.items():\n",
    "    num_values_above_threshold = sum([1 if abs(float(v[0])) >= threshold else 0 for v in values])\n",
    "    if num_values_above_threshold > 0:\n",
    "        pair = combination.replace(\".csv\", \"\").split(\"+\")\n",
    "        unique_pairs.add((pair[0], pair[1]))\n",
    "\n",
    "\n",
    "with open(f'./cache/all_pairs_above_{threshold}_spearman.csv', 'w') as outfile:\n",
    "    for pair in unique_pairs:\n",
    "        outfile.write(f'{pair[0]}, {pair[1]}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0.9\n",
    "unique_pairs = set()\n",
    "\n",
    "for combination, values in combination_tuples_spearman.items():\n",
    "    num_values_above_threshold = sum([1 if abs(float(v[0])) >= threshold else 0 for v in values])\n",
    "    if num_values_above_threshold == len(next(os.walk(store_location))[1]):\n",
    "        pair = combination.replace(\".csv\", \"\").split(\"+\")\n",
    "        unique_pairs.add((pair[0], pair[1]))\n",
    "\n",
    "\n",
    "with open(f'./cache/all_persistent_pairs_above_equal_{threshold}_spearman.csv', 'w') as outfile:\n",
    "    for pair in unique_pairs:\n",
    "        outfile.write(f'{pair[0]}, {pair[1]}\\n')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0.9\n",
    "unique_pairs = set()\n",
    "\n",
    "for combination, values in combination_tuples_spearman.items():\n",
    "    num_values_above_threshold = sum([1 if abs(float(v[0])) >= threshold else 0 for v in values])\n",
    "    if num_values_above_threshold >= 0:\n",
    "        pair = combination.replace(\".csv\", \"\").split(\"+\")\n",
    "        unique_pairs.add((pair[0], pair[1]))\n",
    "\n",
    "\n",
    "with open(f'./cache/all_pairs_above_equal_{threshold}_spearman.csv', 'w') as outfile:\n",
    "    for pair in unique_pairs:\n",
    "        outfile.write(f'{pair[0]}, {pair[1]}\\n')\n",
    "\n"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}