US_Accidents_Statistical Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy import stats\n",
    "from IPython.display import display\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('dec19_400k_rs1_edt_fillna_2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "T0 = df[df['Severity'] < 3].Temperature_filled_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "T1 = df[df['Severity'] >= 3].Temperature_filled_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Severity_less_than_3 count: 268324  |  Severity_3_and_above count: 131676\n"
     ]
    }
   ],
   "source": [
    "print(\"Severity_less_than_3 count:\",T0.count(),\" | \", \"Severity_3_and_above count:\",T1.count())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hypothesis testing\n",
    "Three features were picked for hypothesis testing. <br>\n",
    "**Null Hypothesis:** Preciptation / Temperature /Humidity have no impact on severity of road accidents.<br>\n",
    "**Alternate hypothesis:** Precipitation / Temperature /humidity have an observable effect on severity of road accidents.<br>\n",
    "\n",
    "#### Split data into two samples: \n",
    "Low severity: Severity 1 & 2, [P0 / T0 / H0] (count: 268324) and <br>\n",
    "High severity : Severity 3 & 4 [P1 / T1 /H1] (count: 131676)\n",
    "\n",
    "#### Results:\n",
    "**Precipitation**: <br>\n",
    "Difference in mean of P0 and P1 = -0.00217 <br>\n",
    "Reject the null hypothesis since p-value is zero. Precipitation has an impact on road accident severity. <br>\n",
    "Lower severities are associated with lower mean precipitation, and higher precipitation is associated with more severe road accidents.<br>\n",
    "\n",
    "**Temperature**: <br>\n",
    "Number of samples T0 / T1: 268324 / 131676.\n",
    "Reject the null hypothesis since p-value is zero. Temperature does have an effect on accident severity. since T0 - T1 is positive(0.863), this implies the mean temperatures of severities 1 and 2 are *higer* than mean temperatures of severities 3 and 4. There seems to be a relationship between *lower* temperatures and more severe accidents.<br>\n",
    "\n",
    "**Humidity**:<br>\n",
    "Reject the null hypothesis.<br>\n",
    "*Higher* humidity is associated with more severe accidents. The mean difference in humidity between the two groups is about 0.9%.\n",
    "\n",
    "### Observations:\n",
    "Difference in the mean between the low severity and high severity groups is very small: 0.002inches for Precipitation, less than a degree F for Temperature, and less than 1% for Humidity.\n",
    "\n",
    "#### Sample datasize trials:\n",
    "A.1)  A sample of 1563, for the city of Columbus, was taken from the dataset, and the hypothesis tests re-run for 'Precipitation'. A p-value of 0.66 was obtained.<br>\n",
    "\n",
    "A.2)  A sample of 1651, for the city of Tampa taken from the dataset, and the hypothesis tests re-run for 'Precipitation'. A p-value of 0.287 was obtained.<br>\n",
    "\n",
    "B) Samples of different sizes were taken from the dataset. The table below summarizes the size and p-values for the 'Precipitation' hypotheses tests.\n",
    "\n",
    "| Number of Samples | 50 | 100| 4000| 20000|40000|80000|150000| 220000| 240000| 4.0e+05 |\n",
    "|------------------|-----|-----|-----|-----|-----|-----|------|-------|-------|----------|\n",
    "| p-values          | 0.798|0.267| 0.005|0.087|0.18|0.069|0.002| 0.0003|0.000016| 3.80e-07 |\n",
    "\n",
    "<br>\n",
    "\n",
    "__From the table, we can see a general trend of decreasing p-values as number of random samples increases, within the same dataset.__According to the figure below, 50000 seems to be the sample size beyond which there is a steady and stable decrease in p-values.\n",
    "\n",
    "Stratified sampling of two cities, Columbus and Tampa, shows high p-values at small sample sizes as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_severity_under3 = df[df['Severity'] < 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_severity_over3 = df[df['Severity'] >= 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "P1 = df_severity_over3.Precipitation_filled\n",
    "P0 = df_severity_under3.Precipitation_filled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "T1 = df_severity_over3.Temperature_filled_mean\n",
    "T0 = df_severity_under3.Temperature_filled_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "H1 = df_severity_over3.Humidity_filled_mean\n",
    "H0 = df_severity_under3.Humidity_filled_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### calc_n_mean_std Function\n",
    "is used to centralize the calculation of mean, std and count for a series. These variables are used at different parts of the analysis in the form x[0] to extract the number of rows, x[1] the mean and x[2] the standard deviation of the 1D series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_n_mean_std(series):\n",
    "    \"\"\" calculate count, mean and standard deviation of input series\"\"\"\n",
    "    series_mean = round(np.mean(series), 5)\n",
    "    series_std = round(np.std(series), 3)\n",
    "    series_n = series.count()\n",
    "    return series_n, series_mean, series_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>count, mean, std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(268324, 0.00576, 0.122)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(131676, 0.00793, 0.136)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           count, mean, std\n",
       "0  (268324, 0.00576, 0.122)\n",
       "1  (131676, 0.00793, 0.136)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 = calc_n_mean_std(P1)\n",
    "p0 = calc_n_mean_std(P0)\n",
    "\n",
    "pd.DataFrame({'count, mean, std':(p0, p1)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.002169999999999999"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p0_p1_mean_diff = p0[1] - p1[1]\n",
    "p0_p1_mean_diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value,  3.893993346897233e-07 is very small. Reject Null hypothesis.\n",
      "'P1' has bigger effect on severity, since, -5.074 is a -ve number\n"
     ]
    }
   ],
   "source": [
    "# calculating t-statistic and p-value using scipy.stats:\n",
    "\n",
    "tr = stats.ttest_ind(P0, P1, equal_var=True) # equal variance assumption\n",
    "print(\"p-value, \", tr[1], \"is very small. Reject Null hypothesis.\")\n",
    "print(\"'P1' has bigger effect on severity, since,\", round(tr[0], 3), \"is a -ve number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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>count, mean, std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(268324, 62.65176, 18.509)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(131676, 61.78809, 18.78)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count, mean, std\n",
       "0  (268324, 62.65176, 18.509)\n",
       "1   (131676, 61.78809, 18.78)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = calc_n_mean_std(T1)\n",
    "t0 = calc_n_mean_std(T0)\n",
    "\n",
    "pd.DataFrame({'count, mean, std':(t0, t1)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value,  2.5489171974251004e-43 is very small. Reject Null hypothesis.\n",
      "'T0' has bigger effect on severity, since, 13.802 is a +ve number\n"
     ]
    }
   ],
   "source": [
    "# calculating t-statistic and p-value using scipy.stats:\n",
    "\n",
    "tr_t = stats.ttest_ind(T0, T1, equal_var=True) # equal variance assumption\n",
    "print(\"p-value, \", tr_t[1], \"is very small. Reject Null hypothesis.\")\n",
    "print(\"'T0' has bigger effect on severity, since,\", round(tr_t[0], 3), \"is a +ve number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8636700000000062"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t0_t1_mean_diff = t0[1] - t1[1]\n",
    "t0_t1_mean_diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>count, mean, std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(268324, 65.10025, 22.556)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(131676, 66.00628, 21.917)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             count, mean, std\n",
       "0  (268324, 65.10025, 22.556)\n",
       "1  (131676, 66.00628, 21.917)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h1 = calc_n_mean_std(H1)\n",
    "h0 = calc_n_mean_std(H0)\n",
    "\n",
    "pd.DataFrame({'count, mean, std':(h0, h1)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value,  4.688265062255147e-34 is very small. Reject Null hypothesis.\n",
      "'H1' has bigger effect on severity, since, -12.168 is a -ve number\n"
     ]
    }
   ],
   "source": [
    "# calculating t-statistic and p-value using scipy.stats:\n",
    "\n",
    "tr_h = stats.ttest_ind(H0, H1, equal_var=False) # equal variance assumption\n",
    "print(\"p-value, \", tr_h[1], \"is very small. Reject Null hypothesis.\")\n",
    "print(\"'H1' has bigger effect on severity, since,\", round(tr_h[0], 3), \"is a -ve number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.9060300000000012"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h0_h1_mean_diff = h0[1] - h1[1]\n",
    "h0_h1_mean_diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trials: taking smaller samples for p-value calculations:\n",
    "\n",
    "   *Stratified Sampling*:<br>\n",
    "   A.1) A sample of the dataset (1563), covering only the city of Columbus,OH, is taken and the p-value calculated for 'Precipitation'.<br>\n",
    "    A.2) A sample dataset of similar size (1651) is also taken for city of Tampa, FL, and p-value calculated for 'Precipitation'. <br>\n",
    "    \n",
    "   *Simple Random sampling*:<br>\n",
    "    B) Progressively smaller samples of the dataset are taken, and the p-value calculated for 'Precipitation'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A.1) City of Columbus p-value calculations for Precipitation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Columbus_under3 = df_severity_under3[df_severity_under3['City'] == 'Columbus']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Columbus_over3 = df_severity_over3[df_severity_over3['City'] == 'Columbus']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "P1_columbus = df_Columbus_over3.Precipitation_filled\n",
    "P0_columbus = df_Columbus_under3.Precipitation_filled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>count, mean, std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(768, 0.00611, 0.033)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(795, 0.00684, 0.034)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        count, mean, std\n",
       "0  (768, 0.00611, 0.033)\n",
       "1  (795, 0.00684, 0.034)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p0_columbus = calc_n_mean_std(P0_columbus)\n",
    "p1_columbus = calc_n_mean_std(P1_columbus)\n",
    "pd.DataFrame({'count, mean, std':(p0_columbus, p1_columbus)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value,  0.6664821740422546 is a large number. Accept Null hypothesis.\n",
      "t-statistic is: -0.431\n"
     ]
    }
   ],
   "source": [
    "# calculating t-statistic and p-value using scipy.stats:\n",
    "\n",
    "tr_h = stats.ttest_ind(P0_columbus, P1_columbus, equal_var=True) # equal variance assumption\n",
    "print(\"p-value, \", tr_h[1], \"is a large number. Accept Null hypothesis.\")\n",
    "print(\"t-statistic is:\", round(tr_h[0], 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A.2) City of Tampa p-value calculations for Precipitation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Tampa_under3 = df_severity_under3[df_severity_under3['City'] == 'Tampa']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Tampa_over3 = df_severity_over3[df_severity_over3['City'] == 'Tampa']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "P1_tampa = df_Tampa_over3.Precipitation_filled\n",
    "P0_tampa = df_Tampa_under3.Precipitation_filled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>count, mean, std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(921, 0.0035, 0.04)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(730, 0.00588, 0.05)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       count, mean, std\n",
       "0   (921, 0.0035, 0.04)\n",
       "1  (730, 0.00588, 0.05)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p0_tampa = calc_n_mean_std(P0_tampa)\n",
    "p1_tampa = calc_n_mean_std(P1_tampa)\n",
    "pd.DataFrame({'count, mean, std':(p0_tampa, p1_tampa)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value,  0.28736123031076877 is a large number. Accept Null hypothesis.\n",
      "t-statistic is: -1.064\n"
     ]
    }
   ],
   "source": [
    "# calculating t-statistic and p-value using scipy.stats:\n",
    "\n",
    "tr_h = stats.ttest_ind(P0_tampa, P1_tampa, equal_var=True) # equal variance assumption\n",
    "print(\"p-value, \", tr_h[1], \"is a large number. Accept Null hypothesis.\")\n",
    "print(\"t-statistic is:\", round(tr_h[0], 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### B) P-value tests using different Number of Samples from the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sample = df.sample(n=50, random_state=1) # change value of n for different tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sample_severity_under3 = df_sample[df_sample['Severity'] < 3]\n",
    "df_sample_severity_over3 = df_sample[df_sample['Severity'] >= 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "P1_sample = df_sample_severity_over3.Precipitation_filled\n",
    "P0_sample = df_sample_severity_under3.Precipitation_filled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>count, mean, std</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>(34, 0.00265, 0.011)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(16, 0.00187, 0.007)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       count, mean, std\n",
       "0  (34, 0.00265, 0.011)\n",
       "1  (16, 0.00187, 0.007)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p0_sample = calc_n_mean_std(P0_sample)\n",
    "p1_sample = calc_n_mean_std(P1_sample)\n",
    "pd.DataFrame({'count, mean, std':(p0_sample, p1_sample)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value,  0.7981187950892642 is a large number. Accept Null hypothesis.\n",
      "t-statistic is: 0.257\n"
     ]
    }
   ],
   "source": [
    "# calculating t-statistic and p-value using scipy.stats:\n",
    "\n",
    "tr_h = stats.ttest_ind(P0_sample, P1_sample, equal_var=True) # equal variance assumption\n",
    "print(\"p-value, \", tr_h[1], \"is a large number. Accept Null hypothesis.\")\n",
    "print(\"t-statistic is:\", round(tr_h[0], 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary Table of p-values tests with different Number of Samples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'Number_of_Samples': [50, 100, 400, 4000, 20000, 40000, 80000, 150000, 220000, 240000, 400000],\n",
    "        'p_value': [0.798,0.267, 0.037,0.005, 0.087, 0.18, 0.069, 0.002, 0.0003, 0.0000157, 3.8e-7]\n",
    "       }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pvalues = pd.DataFrame(data,columns=['Number_of_Samples','p_value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot p-values vrs Sample size:\n",
    "\n",
    "df_pvalues.plot(x ='Number_of_Samples', y='p_value', color='red',kind = 'scatter', xlim=[0,400000],ylim=[0, 0.3])\n",
    "plt.title('p-value vrs Number_of_Samples')\n",
    "df_pvalues.plot(x ='Number_of_Samples', y='p_value', kind = 'line', xlim=[0,400000],ylim=[0, 0.3],sharex=ax1)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Number_of_Samples</th>\n",
       "      <td>50.000</td>\n",
       "      <td>100.000</td>\n",
       "      <td>400.000</td>\n",
       "      <td>4000.000</td>\n",
       "      <td>20000.000</td>\n",
       "      <td>40000.00</td>\n",
       "      <td>80000.000</td>\n",
       "      <td>150000.000</td>\n",
       "      <td>220000.0000</td>\n",
       "      <td>240000.000000</td>\n",
       "      <td>4.000000e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>p_value</th>\n",
       "      <td>0.798</td>\n",
       "      <td>0.267</td>\n",
       "      <td>0.037</td>\n",
       "      <td>0.005</td>\n",
       "      <td>0.087</td>\n",
       "      <td>0.18</td>\n",
       "      <td>0.069</td>\n",
       "      <td>0.002</td>\n",
       "      <td>0.0003</td>\n",
       "      <td>0.000016</td>\n",
       "      <td>3.800000e-07</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       0        1        2         3          4         5   \\\n",
       "Number_of_Samples  50.000  100.000  400.000  4000.000  20000.000  40000.00   \n",
       "p_value             0.798    0.267    0.037     0.005      0.087      0.18   \n",
       "\n",
       "                          6           7            8              9   \\\n",
       "Number_of_Samples  80000.000  150000.000  220000.0000  240000.000000   \n",
       "p_value                0.069       0.002       0.0003       0.000016   \n",
       "\n",
       "                             10  \n",
       "Number_of_Samples  4.000000e+05  \n",
       "p_value            3.800000e-07  "
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_pvalues.transpose()"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}