diff options
Diffstat (limited to 'datasets/Talluri2021/2.basic_stats_reports.ipynb')
| -rw-r--r-- | datasets/Talluri2021/2.basic_stats_reports.ipynb | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/datasets/Talluri2021/2.basic_stats_reports.ipynb b/datasets/Talluri2021/2.basic_stats_reports.ipynb new file mode 100644 index 0000000..d33a3cc --- /dev/null +++ b/datasets/Talluri2021/2.basic_stats_reports.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from plotnine import *\n", + "from datetime import datetime\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "or_events = pd.read_parquet('./outage_report_2019-20')\n", + "or_reports = pd.read_parquet('./outage_report_individual_reports_2019-20')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_events = or_events[(or_events['vendor'] != '') & (or_events['vendor'] != 'overview')].copy()\n", + "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n", + "# Combine events with the same event_time, but different status_code with max\n", + "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_or_reports = or_reports[(or_reports['reason'] != '') & (or_reports['vendor'] != 'overview')].reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "thresholded_or_events = filtered_or_events[filtered_or_events['status_code'] > 2].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def proper_vendor_names(series):\n", + " return series.str.capitalize().replace(['Apple-servers', 'Facebook-messenger', 'Youtube'], ['Apple', 'FB Msgr', 'YouTube'])\n", + "\n", + "filtered_or_reports['vendor_proper'] = proper_vendor_names(filtered_or_reports['vendor'])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def proper_vendor_names(series):\n", + " return series.str.capitalize().replace(['Apple-servers', 'Facebook-messenger', 'Youtube'], ['Apple', 'FB Msgr', 'YouTube'])\n", + "\n", + "filtered_or_events['vendor_proper'] = proper_vendor_names(filtered_or_events['vendor'])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Apple',\n", + " 'Github',\n", + " 'Skype',\n", + " 'FB Msgr',\n", + " 'Gmail',\n", + " 'Whatsapp',\n", + " 'Snapchat',\n", + " 'Netflix',\n", + " 'Facebook',\n", + " 'Twitter',\n", + " 'YouTube',\n", + " 'Instagram']" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vendor_list = list(filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'}).sort_values('count')['vendor_proper'])\n", + "vendor_list" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\begin{tabular}{lrrr}\n", + "\\toprule\n", + "vendor\\_proper & count\\_events & count\\_reports & prop \\\\\n", + "\\midrule\n", + " Apple & 3208 & 2566 & 79.99 \\\\\n", + " Github & 4432 & 1062 & 23.96 \\\\\n", + " Skype & 4799 & 2029 & 42.28 \\\\\n", + " FB Msgr & 13788 & 6836 & 49.58 \\\\\n", + " Gmail & 16471 & 9427 & 57.23 \\\\\n", + " Whatsapp & 34653 & 9426 & 27.20 \\\\\n", + " Snapchat & 68863 & 8118 & 11.79 \\\\\n", + " Netflix & 74631 & 20211 & 27.08 \\\\\n", + " Facebook & 79880 & 25886 & 32.41 \\\\\n", + " Twitter & 136672 & 20252 & 14.82 \\\\\n", + " YouTube & 152169 & 26783 & 17.60 \\\\\n", + " Instagram & 193687 & 41574 & 21.46 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\n" + ] + } + ], + "source": [ + "event_count_df = filtered_or_events.groupby('vendor_proper')['status_code'].sum().reset_index().rename(columns={'status_code':'count'})\n", + "report_count_df = filtered_or_reports.groupby('vendor_proper')['country'].count().reset_index().rename(columns={'country':'count'}).set_index('vendor_proper')\n", + "\n", + "joined_count_df = event_count_df.join(report_count_df, on='vendor_proper', lsuffix='_events', rsuffix='_reports')\n", + "joined_count_df['prop'] = (joined_count_df['count_reports'] / joined_count_df['count_events']) * 100\n", + "joined_count_df['count_events'] = joined_count_df['count_events'].astype(int)\n", + "\n", + "print(joined_count_df.sort_values('count_events').to_latex(index=None, float_format=\"%.2f\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "783253\n", + "174170\n", + "0.22236748534636958\n" + ] + } + ], + "source": [ + "#\n", + "print(joined_count_df['count_events'].sum())\n", + "print(joined_count_df['count_reports'].sum())\n", + "print(joined_count_df['count_reports'].sum() / joined_count_df['count_events'].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<ipython-input-34-de7f15117fb8>:3: FutureWarning: Series.dt.weekofyear and Series.dt.week have been deprecated. Please use Series.dt.isocalendar().week instead.\n" + ] + } + ], + "source": [ + "filtered_or_events['evtime'] = pd.to_datetime(filtered_or_events['event_time'], unit='s')\n", + "filtered_or_events['hour_of_week'] = filtered_or_events['evtime'].dt.dayofweek * 24 + (filtered_or_events['evtime'].dt.hour + 1)\n", + "filtered_or_events['week_of_year'] = filtered_or_events['evtime'].dt.weekofyear" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2019-04-14 11:20:00\n", + "2020-10-31 23:00:00\n" + ] + } + ], + "source": [ + "# First and last dates in the dataset\n", + "print(filtered_or_events['evtime'].min())\n", + "print(filtered_or_events['evtime'].max())" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "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>hour_of_week</th>\n", + " <th>sum</th>\n", + " <th>prop</th>\n", + " <th>vendor_proper</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>1</td>\n", + " <td>19.0</td>\n", + " <td>0.142857</td>\n", + " <td>Apple</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>2</td>\n", + " <td>40.0</td>\n", + " <td>0.300752</td>\n", + " <td>Apple</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>3</td>\n", + " <td>81.0</td>\n", + " <td>0.609023</td>\n", + " <td>Apple</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>4</td>\n", + " <td>124.0</td>\n", + " <td>0.932331</td>\n", + " <td>Apple</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>5</td>\n", + " <td>22.0</td>\n", + " <td>0.165414</td>\n", + " <td>Apple</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>163</th>\n", + " <td>164</td>\n", + " <td>2431.0</td>\n", + " <td>0.413717</td>\n", + " <td>YouTube</td>\n", + " </tr>\n", + " <tr>\n", + " <th>164</th>\n", + " <td>165</td>\n", + " <td>1151.0</td>\n", + " <td>0.195882</td>\n", + " <td>YouTube</td>\n", + " </tr>\n", + " <tr>\n", + " <th>165</th>\n", + " <td>166</td>\n", + " <td>450.0</td>\n", + " <td>0.076583</td>\n", + " <td>YouTube</td>\n", + " </tr>\n", + " <tr>\n", + " <th>166</th>\n", + " <td>167</td>\n", + " <td>398.0</td>\n", + " <td>0.067733</td>\n", + " <td>YouTube</td>\n", + " </tr>\n", + " <tr>\n", + " <th>167</th>\n", + " <td>168</td>\n", + " <td>398.0</td>\n", + " <td>0.067733</td>\n", + " <td>YouTube</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>2016 rows × 4 columns</p>\n", + "</div>" + ], + "text/plain": [ + " hour_of_week sum prop vendor_proper\n", + "0 1 19.0 0.142857 Apple\n", + "1 2 40.0 0.300752 Apple\n", + "2 3 81.0 0.609023 Apple\n", + "3 4 124.0 0.932331 Apple\n", + "4 5 22.0 0.165414 Apple\n", + ".. ... ... ... ...\n", + "163 164 2431.0 0.413717 YouTube\n", + "164 165 1151.0 0.195882 YouTube\n", + "165 166 450.0 0.076583 YouTube\n", + "166 167 398.0 0.067733 YouTube\n", + "167 168 398.0 0.067733 YouTube\n", + "\n", + "[2016 rows x 4 columns]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_df_list = []\n", + "for vendor in filtered_or_events['vendor_proper'].unique():\n", + " vendor_df = filtered_or_events[filtered_or_events['vendor_proper'] == vendor].copy()\n", + " partial_grouped_df = vendor_df.groupby('hour_of_week')['status_code'].sum().reset_index().rename(columns={'status_code': 'sum'})\n", + " partial_grouped_df['prop'] = partial_grouped_df['sum'] / partial_grouped_df['sum'].max()\n", + " partial_grouped_df['vendor_proper'] = vendor\n", + " grouped_df_list.append(partial_grouped_df)\n", + "grouped_df = pd.concat(grouped_df_list)\n", + "grouped_df" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:727: PlotnineWarning: Saving 14 x 3 in image.\n", + "/Users/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:730: PlotnineWarning: Filename: plots/or_hour_of_week.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1400x300 with 12 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "<ggplot: (306119497)>" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_df['vendor_cat'] = pd.Categorical(grouped_df['vendor_proper'], categories=vendor_list, ordered=True)\n", + "\n", + "vendor_maxes = grouped_df.groupby('vendor_proper')['sum'].max()\n", + "\n", + "def label_func(vendor):\n", + " if vendor == 'Apple':\n", + " return vendor + ' (max={:,})'.format(int(vendor_maxes.loc[vendor]))\n", + " else:\n", + " return vendor + ' ({:,})'.format(int(vendor_maxes.loc[vendor]))\n", + "\n", + "plt = ggplot(grouped_df) +\\\n", + " theme_classic(base_size=12, base_family='sans-serif') +\\\n", + " theme(figure_size=(14, 3),\n", + " axis_text_y=element_text(margin={'r': 5}),\n", + " panel_grid_minor_x=element_line(size=0.7, color=\"gainsboro\"),\n", + " panel_grid_major_x=element_blank(),\n", + " text=element_text(size=12)) +\\\n", + " geom_step(aes(x=\"hour_of_week\", y=\"prop\")) +\\\n", + " facet_wrap(facets='vendor_cat', nrow=2, labeller=label_func) +\\\n", + " scale_x_continuous(breaks = [12, 36, 60, 84, 108, 132, 156],\n", + " labels = [\"Mo\", \"Tu\", \"We\", \"Th\", \"Fr\", \"Sa\", \"Su\"]) +\\\n", + " xlab(\"Day of Week\") +\\\n", + " ylab(\"Max. Norm. Failures/Hour\")\n", + "\n", + "plt.save('plots/or_hour_of_week.pdf')\n", + "plt" + ] + } + ], + "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.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} |