Stats with Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2c28ef6f",
   "metadata": {},
   "source": [
    "# <font color=\"hotpink\"> Statistics with Python</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df2934ec",
   "metadata": {},
   "source": [
    "## <font color=\"#fe7401\"> Permutation and Combination </font>\n",
    "\n",
    "* Permutation means arrange ie. order matters.\n",
    "* Combinations means select ie. order doesn't matter.\n",
    "<img src=\"background/permu_comb.png\" width=\"300\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0757df80",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import itertools\n",
    "import math\n",
    "import warnings\n",
    "import statistics\n",
    "from scipy import stats\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline\n",
    "\n",
    "# help(itertools)\n",
    "# help(statistics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "da5d7400",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([ch for ch in \"HORSE\"])\n",
    "print(len(list(itertools.combinations(arr, 2))))\n",
    "print(len(list(itertools.permutations(arr, 2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2f2a724c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]\n",
      "[(1, 2), (1, 3), (2, 3)]\n"
     ]
    }
   ],
   "source": [
    "print(list(itertools.permutations([1,2,3], 2)))\n",
    "print(list(itertools.combinations([1,2,3], 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9ec9134d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6720.0\n"
     ]
    }
   ],
   "source": [
    "def nCr(n, r):\n",
    "    return math.factorial(n) / (math.factorial(r)*math.factorial(n-r))\n",
    "\n",
    "# how many ways can 10 balls be picked from 7 red out of 10, and 3 blue out of 8\n",
    "print(nCr(10, 7) * nCr(8, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6c43622",
   "metadata": {},
   "source": [
    "## <font color=\"#fe7401\">Descriptive Statistics</font>\n",
    "* Measures of Dispersion provide insights on the spread of given dataset.\n",
    "* Major measures of dispersion are: range, percentile, inter-quartile range, standard deviation, variance, skewness, and kurtosis.\n",
    "* **Range** is the difference between maximum and minimum values of the dataset.\n",
    "* **Percentile** refers to a value, below which lies given the percentage of data points.\n",
    "* E.g., 45th percentile refers to a value below which 45% of data points are found.\n",
    "* `percentile` function of numpy can be used to compute a single or multiple percentiles.\n",
    "* Three **Quartiles** namely, Q1 Q2 and Q3, split the entire dataset into four equal parts. Each part contains 25% of data.\n",
    "* **Inter quartile range** refers to difference between third quartile (Q3) and first quartile (Q1).\n",
    "* `iqr` method from scipy.stats can be used for calculating it.\n",
    "* **Variance** is defined as the average of squared differences, of each data point from dataset's mean.\n",
    "* **Standard Deviation** is square root of variance.\n",
    "* `var` and `std` functions of numpy can be used for computing variance and standard deviation respectively.\n",
    "* By default, the functions assume that the dataset represents entire population. To represent a sample, derived from a population, `ddof` parameter is set to 1.\n",
    "* **skewness** determines whether the majority of data points are present on one side of the distribution.\n",
    "* A positive value represents right skewed distribution; a negative value represents left skewed one, zero represent unskewed distribution.\n",
    "* **Positively skewed** (or right-skewed) distribution is a type of distribution in which most values are clustered around the left tail of the distribution while the right tail of the distribution is longer.\n",
    "* **Kurtosis** indicates how much of data is concentrated around mean or shape of the probability distribution.\n",
    "* It can be estimated using `kurtosis` function of scipy.stats module.\n",
    "* By default, it uses Fisher’s definition. This can be changed to Pearson by setting fisher parameter to False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e606ad79",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 2.75\n",
      "Median: 3.0\n",
      "Mode: 4\n",
      "Population stddev: 1.299038105676658\n",
      "Population variance: 1.6875\n"
     ]
    }
   ],
   "source": [
    "arr = [1,2,4,4]\n",
    "print(\"Mean:\", statistics.mean(arr))\n",
    "print(\"Median:\", statistics.median(arr))\n",
    "print(\"Mode:\", statistics.mode(arr))\n",
    "print(\"Population stddev:\", statistics.pstdev(arr))\n",
    "print(\"Population variance:\", statistics.pvariance(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b7d72325",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "4.5\n",
      "ModeResult(mode=array([5]), count=array([3]))\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([2,3,4,5,5,5])\n",
    "print(np.mean(arr))\n",
    "print(np.median(arr)) # (4+5)/2 -> 4.5\n",
    "print(stats.mode(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0c0e84a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46\n"
     ]
    }
   ],
   "source": [
    "s1 = np.array([86, 47, 45, 47, 40])\n",
    "print(np.ptp(s1))  # range or peak to peak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "29113eab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([40, 45, 47, 47, 65, 75, 83, 86, 97, 98])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = np.array([86, 47, 45, 47, 40, 97, 98, 75, 65, 83])\n",
    "print(np.percentile(s2, 45, interpolation=\"lower\"))\n",
    "s2.sort()\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e4e6aa72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([47, 65, 83])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# interpolation keyword is going to be deprecated in numpy\n",
    "np.percentile(s2, [25,50,75], method=\"lower\")   # Q1, Q2 and Q3 quartiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "10a3b48f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.iqr(s2, rng=[25,75], interpolation=\"lower\")    # Q3 - Q1 -> 83 - 47 -> 36"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b3a85c6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "454.21000000000004\n",
      "21.312203077110542\n",
      "504.6777777777778\n",
      "22.46503455990615\n"
     ]
    }
   ],
   "source": [
    "print(np.var(s2))   # for population\n",
    "print(np.std(s2))\n",
    "print(np.var(s2, ddof=1))   # for sample ie. N - 1\n",
    "print(np.std(s2, ddof=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ff710ac0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.7661328409045185\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "s3 = [1,2,3,4,5,6,7,8,9,10,99,98]\n",
    "print(stats.skew(s3))    # positive skew, most values around left tail\n",
    "\n",
    "sns.distplot(s3, bins=3)   # distribution plot, depicts the variation in the data distribution.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3fea24c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 99, 98]\n",
      "Mean: 21.0\n",
      "Kurtosis: 1.1599354083897495\n"
     ]
    }
   ],
   "source": [
    "print(s3)\n",
    "print(\"Mean:\", np.mean(s3))\n",
    "print(\"Kurtosis:\", stats.kurtosis(s3))  # an example of positive kurtosis, most of the data around the mean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd992e36",
   "metadata": {},
   "source": [
    "### Kurtosis\n",
    "![Kurtosis](./background/kurtosis.webp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b77c64cf",
   "metadata": {},
   "source": [
    "## <font color=\"#fe7401\"> Random Numbers, Variables and Distributions </font>\n",
    "* A random number is a number, chosen by chance from a distribution.\n",
    "* Python provides a lot of modules, which deal with random numbers.\n",
    "    1. random module of python standard library.\n",
    "    2. random module of Numpy\n",
    "    3. stats module of Scipy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf9d311b",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> numpy's random module </font>\n",
    "* `random` module of `numpy` has utilities, which generate arrays of random numbers.\n",
    "* E.g.: rand function generates uniformly distributed numbers from range [0, 1]\n",
    "* rand function with no arguments generate a single random value.\n",
    "* By passing arguments, it generates a random array of specified size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "edc66566",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5160629912059577\n",
      "[[0.08436813 0.64816336 0.46767813]\n",
      " [0.50761331 0.62441817 0.74315   ]]\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(np.random.rand())\n",
    "print(np.random.rand(2,3))\n",
    "print(np.random.randint(1,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "56c14167",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 22]\n"
     ]
    }
   ],
   "source": [
    "# two items are selected randomly, without replacement.\n",
    "print(np.random.choice([11, 22, 33], 2, replace=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c343c2e7",
   "metadata": {},
   "source": [
    "#### <font color=\"grey\">random.seed()</font>\n",
    "* **seed** is a number that sets the initial state of random number generator.\n",
    "* setting a seed, helps in generating the same sequence of random numbers, repeatedly.\n",
    "* seed method of a random module can be used to set a seed as shown in below example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "517fc496",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5434049417909654\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(100)\n",
    "print(np.random.rand())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "eabb9ebc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5434049417909654\n"
     ]
    }
   ],
   "source": [
    "# we got same value even after applying random bcs of seed\n",
    "np.random.seed(100)\n",
    "print(np.random.rand())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6345c0b0",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> Random Distributions </font>\n",
    "* `scipy.stats` module provide a lot of methods for created discrete and continuous random variables.<br>\n",
    "* Commonly used methods are described below.\n",
    "    * **pdf / pmf** : Probability distribution function (continuous) or probability mass function (discrete).\n",
    "    * **cdf** : Cumulative distribution function.\n",
    "    * **sf** : Survival function (1 – cdf).\n",
    "    * **rvs** : Creating random samples from a distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d61ec7e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00895781 0.02159639 0.04436833]\n",
      "[0.00819754 0.02275013 0.05479929]\n",
      "[[3.59590311 0.87730624 5.88668613]\n",
      " [3.03483917 4.42031951 5.5199392 ]]\n"
     ]
    }
   ],
   "source": [
    "# defines a normal continuous random variable of mean (bell curve's peak) 1.0 and std dev. (flatness) 2.5.\n",
    "x = stats.norm(loc=5, scale=2.5)\n",
    "\n",
    "# It also estimates probabilities and cumulative probabilities at -1, 0 and 1.\n",
    "print(x.pdf([-1, 0, 1]))\n",
    "print(x.cdf([-1, 0, 1]))\n",
    "\n",
    "# generates six random numbers from defined normal distribution.\n",
    "print(x.rvs((2,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f845a2ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGdCAYAAAD60sxaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABX20lEQVR4nO3deVzb9R0/8Nc3CUk4wx3uo0LvFnoita46mdRjWqtbdc4ec93mvFE360/b3ehs+0Nnf3a6eU27djrtnEe1orW60gtKa++WtkCBhDuBAAkk398fgSgWWqCBT0Jez8cjj9FvPgnvLBJefE5JlmUZRERERD5EIboAIiIiopHGAEREREQ+hwGIiIiIfA4DEBEREfkcBiAiIiLyOQxARERE5HMYgIiIiMjnMAARERGRz1GJLsATORwOVFdXIzg4GJIkiS6HiIiIBkCWZbS0tCAuLg4Kxfn7eBiA+lBdXY3ExETRZRAREdEQVFZWIiEh4bxtGID6EBwcDMD5f2BISIjgaoiIiGggzGYzEhMTXb/Hz4cBqA89w14hISEMQERERF5mINNXOAmaiIiIfA4DEBEREfkcBiAiIiLyOQxARERE5HMYgIiIiMjnMAARERGRz2EAIiIiIp/DAEREREQ+hwGIiIiIfA4DEBEREfkcBiAiIiLyOQxARERE5HMYgIiIiMjnMAARERGRz1GJLoCIaKRt2FVx3vt/lJU0QpUQkSjsASIiIiKfwwBEREREPkd4AFq3bh1SUlKg1WqRlZWF3bt399v20KFDuPnmm5GSkgJJklBQUNBnu6qqKvz4xz9GREQE/P39MWXKFOzdu3eYXgERERF5G6FzgDZt2oS8vDysX78eWVlZKCgoQG5uLo4dO4bo6Ohz2re1tWHMmDH4wQ9+gAcffLDP52xqasJll12GK6+8Eh9++CGioqJw4sQJhIWFDffLISI34RwdIhpuQgPQ2rVrsXz5cixbtgwAsH79erz//vt46aWX8Oijj57TftasWZg1axYA9Hk/ADz11FNITEzEyy+/7LqWmpo6DNUTERGRtxI2BGaz2VBcXIycnJyvi1EokJOTg6KioiE/77vvvouZM2fiBz/4AaKjozFt2jS8+OKL532M1WqF2WzudSMiIqLRS1gAqq+vh91uh16v73Vdr9fDYDAM+XlPnTqF559/Hunp6fjoo49w11134b777sOrr77a72Py8/Oh0+lct8TExCF/fyIiIvJ8widBu5vD4cD06dPxpz/9CdOmTcPPfvYzLF++HOvXr+/3MStWrIDJZHLdKisrR7BiIiIiGmnCAlBkZCSUSiWMRmOv60ajETExMUN+3tjYWEycOLHXtQkTJqCiov9JlRqNBiEhIb1uRERENHoJC0BqtRozZsxAYWGh65rD4UBhYSGys7OH/LyXXXYZjh071uva8ePHkZycPOTnJCIiotFF6CqwvLw8LFmyBDNnzsTs2bNRUFAAi8XiWhW2ePFixMfHIz8/H4Bz4vThw4ddX1dVVaG0tBRBQUFIS0sDADz44IOYM2cO/vSnP+GHP/whdu/ejRdeeAEvvPCCmBdJREREHkdoAFq0aBHq6uqwcuVKGAwGZGZmYsuWLa6J0RUVFVAovu6kqq6uxrRp01z/Xr16NVavXo158+Zh27ZtAJxL5d955x2sWLECv/vd75CamoqCggLcfvvtI/raiIiIyHNJsizLoovwNGazGTqdDiaTifOBiAQY7o0QudEi0eg0mN/fPA2eiLySLMs4UtOCjw4ZcNzYgrK6VjS1daKj0w5ZBoI0KgRrVUgKD0BqZCCmJYVhblokdAF+oksnIg/AAEREXkWWZbxVfBbPbzuJsjpLv+1arV0wmIETta3dV05DApAaFYjL06IwVh8ESZJGpGYi8jwMQETkNWpbOrB5XzXONDiDj1qlwHfHRWNWajjGRAVCH6yF1k+B9w7UwNblQJvNjgaLFUazFafqWlHbYsWpOgtO1VkQq9NiQWY8EsMDBL8qIhKBAYiIvMLpegteKzoDa5cD/n5K3HdVOn58aRKCtecOaUUGaVxfpyHI9XWTxYaiUw3YfboRNaYO/HV7Ga4cH40rxkZDqWBvEJEvYQAiIo933NiCN3aVo9MuIyUiAK//NAsJYYPvuQkLVOPaKbG4YmwU/rO/Gl9VmVB4pBZVTe24bXYS/JSjbnN8IuoHf9qJyKNVNrbhHzud4WecPhjLLksdUvj5pgCNCrfOSsQPZyZApZBw1NCCfxSVw9blcFPVROTpGICIyGO1WruwYXcF7A4Z42OCcful7uulkSQJmYlhWDonBWqlAifrWvHazjOwO7gzCJEvYAAiIo/kkGX8a28lTO2diAhU44czE6FSuP8ja0xUEH4yNxUalQKn6ix470C1278HEXkezgEiIo/05Yl6nKxthZ9Swu2XJkPrp3Tdd6GNDAcrKTwAP5yZiNd3lmPX6Ua8vrMcP76U5wcSjWbsASIij9NksaHwqBEAcP3UOMSEaIf9e06IDcHVE53H8Pzm3UP46qxp2L8nEYnDAEREHkWWZby7v7p7xVcgZiaHjdj3/s7YKEyKC0GXQ8ZDb5aio9M+Yt+biEYWAxAReZQPDxpwzNgCpSRhwbS4Ed2tWZIkLMiMR2SQGseNrfi/nxwfse9NRCOLAYiIPIa1y44/fXAEgLM3Jjp4+Ie+vi1Qo0L+wqkAgBe2n0JJRdOI10BEw48BiIg8xj+KynG2qR0hWhXmjY0SVsf3JuqxcFo8ZBlY9Z9DcHBpPNGowwBERB7B1N6J5z47CQDImaCHWiX242nFtRMQrFHhqyoT3iyuFFoLEbkfAxAReYTnt5Whua0T6dFBmJY0chOf+xMVrMH9OekAgD9vOQZTe6fgiojInRiAiEi42pYOvLLjNADg1/PHe8zBpIuzU3BJVCAaLDY89+kJ0eUQkRsxABGRcOu3nUJHpwPTkkJx1YRo0eW4qFUKPH79RADAa0XlMJo7BFdERO7CAEREQtWaO/DGrnIAwIM5Y0d02ftAXDE2CjOSw2DtcmBd9xwlIvJ+DEBEJNTzn5fB2uXA9KRQXJ4eKbqcc0iShIe+NxYAsHF3Jaqa2wVXRETuwABERMLUmjtc53o9+D3P6/3pMSctEpeOCYfN7uBcIKJRggGIiIR58YtTsHY5MCM5DHPTPK/355seunocAOCt4rMwmDgXiMjb8TR4IhKiyWLDG929P/dcmeZRvT/9nTafEhGAMw1teHnHaay4ZsIIV0VE7sQeICIS4uUdZ9Bms2NSXAiuGCdu1+fBuDzdWeeGnRVo6eC+QETejAGIiEZcS0cnXvmfc9+fuz2s9+d8xsUEIzJIgxZrFzbt4e7QRN6MAYiIRtzrOytg7ujCmKhA5E6KEV3OgCkkCZd3z1V66cvT6LQ7BFdEREPFAEREI6qj046/f3kKAPDLK9I8ZtfngcpMCkVkkBrVpg58ctgouhwiGiJOgiYit+tvEjEAFJXVo77VhrAAP7Tb7Odt64n8lAosmpWIdZ+V4Y1dFbhmSqzokohoCNgDREQjpsvhwPYT9QCcE4q9rfenx22zkyBJwJcn63G63iK6HCIaAvYAEdGIKa1ohqm9E8EaFWYkiz/xfai2H6/H2OhgHDO24InNB3Htt3qBfpSVJKgyIhoo9gAR0YhwyLKr92dueiT8lN798ZOVGg4AKC5v4mRoIi/k3Z9AROQ1jhlaUN9qhdZPgdkp4aLLuWhjY4Kh8/dDe6cdB6tMosshokHyiAC0bt06pKSkQKvVIisrC7t37+637aFDh3DzzTcjJSUFkiShoKDgvM/95JNPQpIkPPDAA+4tmogG5Yvu3p/ZKeHQ+CkFV3PxFJKEmSnOYbySiibB1RDRYAkPQJs2bUJeXh5WrVqFkpISZGRkIDc3F7W1tX22b2trw5gxY/Dkk08iJub8+4fs2bMHf/3rXzF16tThKJ2IBqiysQ1nGixQSED2JZ595tdgTE90BqBTdRY0t9kEV0NEgyE8AK1duxbLly/HsmXLMHHiRKxfvx4BAQF46aWX+mw/a9YsPP3007j11luh0Wj6fd7W1lbcfvvtePHFFxEW5r2TLYlGgy9POnt/MhJCofP3E1yN+4QFqpEaGQgZQGlls+hyiGgQhAYgm82G4uJi5OTkuK4pFArk5OSgqKjoop777rvvxnXXXdfruftjtVphNpt73YjIPZosNtccmbnpo6f3p8f0pFAAzmEwWZbFFkNEAyY0ANXX18Nut0Ov1/e6rtfrYTAYhvy8GzduRElJCfLz8wfUPj8/HzqdznVLTEwc8vcmot7+V1YPGUB6dBBidf6iy3G7yXE6+Ckl1LfaUNnYJrocIhog4UNg7lZZWYn7778fb7zxBrRa7YAes2LFCphMJtetspKHHBK5Q7vNjr1nnBOE56aNvt4fAND4KTEpTgcAKKloFlsMEQ2Y0AAUGRkJpVIJo7H3eTpGo/GCE5z7U1xcjNraWkyfPh0qlQoqlQqff/45nn32WahUKtjt9nMeo9FoEBIS0utGRBdv9+kG2OwOxIRokRYdJLqcYTOtexjsYLUJdgeHwYi8gdAApFarMWPGDBQWFrquORwOFBYWIjs7e0jPedVVV+Grr75CaWmp6zZz5kzcfvvtKC0thVLp/ctvibxBl92BHacaADjn/kiSdx57MRBjIoMQqFaizWZHWV2r6HKIaACEH4WRl5eHJUuWYObMmZg9ezYKCgpgsViwbNkyAMDixYsRHx/vms9js9lw+PBh19dVVVUoLS1FUFAQ0tLSEBwcjMmTJ/f6HoGBgYiIiDjnOhENn6+qTGjp6EKIVoWpCTrR5QwrpULC5Hgddp1uxIGz3BSRyBsID0CLFi1CXV0dVq5cCYPBgMzMTGzZssU1MbqiogIKxdcdVdXV1Zg2bZrr36tXr8bq1asxb948bNu2baTLJ6J+7Ozu/ckaEwGVYtRNNzzH1IRQ7DrdiMM1Jli77NCo2NtM5Mkkmes2z2E2m6HT6WAymTgfiGgInt5yDOu2nYRSkvCr+eMQrB09e//0xyHL+POWozB3dOFvi2ciZ6L+wg8iIrcazO/v0f9nGRGNuJ7en8nxIT4RfgDn0RiT451Dff89UC24GiK6EAYgInKrJosN+882AwCyx0SILWaETe0OQJ8cNqKj89wVp0TkORiAiMit3iyuRJdDRpxOi8TwANHljKjE8ACEBvjBYrPjs6N9n2dIRJ6BAYiI3EaWZWzc7dxINCs1YlQvfe+LJEmY0t0L9N6BGsHVENH5MAARkdvsOdOEU/UWqFUKTE0c3Uvf+zM1PhQAUHjUCIu1S2wxRNQvBiAicpuNuysAOOfC+Ooy8LhQLVIiAtDR6cAnR4wXfgARCcEARERuYWrvxPtfOYd9ZqWEC65GHEmScP3UOAAcBiPyZAxAROQW75ZWwdrlwPiYYCSEjb5T3wfj+oxYAMDnx+pg7ugUXA0R9YUBiIjcYtNe5+TnRbMSfW7y87eN0wcjPToINrsDWw9xGIzIEzEAEdFFO2ZowcEqM/yUEhZkxosuRzhJknDdVGcvUM+wIBF5FgYgIrpob+87CwD47vhohAWqBVfjGa7vDkBfnKiDqY3DYESehgGIiC6K3SFj874qAMBN0xIEV+M50qKDMT4mGJ12GR8fNoguh4i+hQGIiC7KjrJ6GM1WhAb44crxUaLL8SjXTXH2AnE1GJHnYQAioovyTomz9+f7U+N8du+f/lzbPQz2v5P1aLLYBFdDRN/EAEREQ9Zm68KHB53DOwunc/Lzt10SFYQJsSHocnAYjMjTMAAR0ZB9cqQW7Z12pEQEIDMxVHQ5HqlnMjSHwYg8CwMQEQ3Zf/dXAwC+nxHn83v/9KdnHtCOsgY0tFoFV0NEPRiAiGhITO2d+PxYHQBnAKK+pUQGYnJ8COwOGR9xU0Qij6ESXQAReZ4NuyrOe/+PspLw8SEDbHYHxumDMVYfPEKVeafrpsThYJUZ739VjR9lJYkuh4jAHiAiGqL/ds9p6ZnjQv3rGQYrKmtAPYfBiDwCe4CIaNAaWq3438l6AMD1HP46R189aPGh/qhqbsfv3zuMZ26dJqAqIvom9gAR0aB9dMgIu0PG5PgQpEYGii7HK0yJ1wEADpw1Ca6EiAAGICIagi2HnHvaXDuFw18DNSXBGYDO1FtQ29IhuBoiYgAiokFpt9mxo3v4a/6kGMHVeI+wADUSw/whA9hykJsiEonGAEREg3LUYEaXQ8ZYfRDGRAWJLser9AyDcVNEIvEYgIhoUA5VmwGw92coJncHoD1nGmE0cxiMSCQGICIaMFuXAydqWwAAuZMZgAYrNECNpPAAyDLwwVfsBSISicvgiWjAjhtb0GmXERbgh9KKZuyv5IqmwZoSr0NFYxveP1CDZZelii6HyGexB4iIBuxwjXP4a1Kcjmd/DVHPMNje8ibUmNoFV0PkuxiAiGhAHLKMYwbn8NeE2BDB1Xgvnb8fZqWEAQA++IqrwYhEYQAiogGpbGxDe6cdWj8FksIDRJfj1Xr2T+I8ICJxGICIaECOdvf+jNUHQ6ng8NfFuGZyLCQJKC5vQnUzh8GIRPCIALRu3TqkpKRAq9UiKysLu3fv7rftoUOHcPPNNyMlJQWSJKGgoOCcNvn5+Zg1axaCg4MRHR2NBQsW4NixY8P4CohGv6MG5/yfCTEc/rpYMTotZiY7h8E+5KaIREIID0CbNm1CXl4eVq1ahZKSEmRkZCA3Nxe1tbV9tm9ra8OYMWPw5JNPIiam72W4n3/+Oe6++27s3LkTW7duRWdnJ66++mpYLJbhfClEo1aTxQaj2QqFBKTrufmhO/ScEP/+gWrBlRD5JuEBaO3atVi+fDmWLVuGiRMnYv369QgICMBLL73UZ/tZs2bh6aefxq233gqNRtNnmy1btmDp0qWYNGkSMjIy8Morr6CiogLFxcXD+VKIRq2e3p+k8EAEqLl7hjtcM8U5DFZS0cxhMCIBhAYgm82G4uJi5OTkuK4pFArk5OSgqKjIbd/HZHLuVRIeHt7n/VarFWazudeNiL7WM/9nfEyw4EpGD32IFrOSnZ9JnAxNNPKEBqD6+nrY7Xbo9fpe1/V6PQwG94yLOxwOPPDAA7jsssswefLkPtvk5+dDp9O5bomJiW753kSjQafdgdP1zuHjcQxAbnXd1O5hMAYgohEnfAhsuN199904ePAgNm7c2G+bFStWwGQyuW6VlZUjWCGRZztTb0GXQ4bO3w/RwX0PO9PQXDM5BpIE7KtoRhWHwYhGlNAAFBkZCaVSCaPR2Ou60Wjsd4LzYNxzzz1477338NlnnyEhIaHfdhqNBiEhIb1uROR0orYVAJAWHcTdn90sOkSLWSnOYbAP2QtENKKEBiC1Wo0ZM2agsLDQdc3hcKCwsBDZ2dlDfl5ZlnHPPffgnXfewaefforUVJ63QzRUJ7sDUHo0V38Nh+s5DEYkhPAhsLy8PLz44ot49dVXceTIEdx1112wWCxYtmwZAGDx4sVYsWKFq73NZkNpaSlKS0ths9lQVVWF0tJSnDx50tXm7rvvxuuvv44NGzYgODgYBoMBBoMB7e3sYiYaDHNHJwzmDkgALoliABoO878xDHa2qU10OUQ+Q/h61kWLFqGurg4rV66EwWBAZmYmtmzZ4poYXVFRAYXi65xWXV2NadOmuf69evVqrF69GvPmzcO2bdsAAM8//zwA4Iorruj1vV5++WUsXbp0WF8P0WjS0/sTF+qPQI3wj4tRY8Ouil7/TokIxOl6C/74/hFcnh6FH2UlCaqMyHd4xCfaPffcg3vuuafP+3pCTY+UlBTIsnze57vQ/UQ0MBz+GhmT40Jwut6CIzVmXJ4eJbocIp8gfAiMiDyTQ5a/ngDN3Z+H1fhY58KL8oY2tFm7BFdD5BsYgIioT0ZzByzWLqiVPP19uIUFqBETooUM4JixRXQ5RD6BAYiI+nSqzrn5YXJEAFQKflQMt/Gxzk0mjxgYgIhGAj/ViKhPp7p3fx7D1V8jYkKMcxjshLEFti6H4GqIRj8GICI6h0OWcaYnAEUGCq7GN8SH+SNIo4K1y4HdpxtFl0M06nnEKjAi8iwGUwfaO+1QqxSIC/UXXY5PUEgSxsUEo7i8Ceu2nURFY/97AnGZPNHFYw8QEZ2jZ/grJSIASgWPvxgpE7oPmz3GeUBEw44BiIjOcarOufx9TCTn/4ykS6KCoJCARosNjRab6HKIRjUGICLqxe6QcaahZwI05/+MJI2fEondWw6cqGUvENFwYgAiol4OV5vR0emARqVArI7zf0ZaWveu2z27cBPR8GAAIqJedp1uAOA8n4rzf0Zeeve2A6fqLHDwWB+iYcMARES97DnjXIKdyuXvQsSHBUDrp0B7px3Vze2iyyEatRiAiMhFlmXsPdMEwLkDNI08pUJyTT7nMBjR8GEAIiKX0/UWNFhsUCkkxHP/H2F65gGdYAAiGjYMQETk0tP7kxDmD5WSHw+i9ASgioY2HotBNEz4CUdELj3zf5IjOP9HpIhANXT+frDL8nl3hCaioWMAIiKXngCUwvk/QkmS5JqE3rMnExG5FwMQEQEAals6cKahDZIEJIWzB0i0nknoPYfSEpF7MQAREQCguHv+zzh9MPzVSsHVUGr3MGRFYxu6HJwHRORuDEBEBADY0x2AZqWEC66EACAqWIMAtRJdDhnVTdwPiMjdGICICABQXOEMQDNTwgRXQoBzHlBKdy/Q6QZOhCZyNwYgIkJHpx2Hq00AgOlJDECeIqVnIjTnARG5HQMQEeFQtQmddhmRQWokhHEDRE/RsxqvvJHnghG5GwMQEWFfRTMAYFpSGCSJB6B6ilidP9QqBTo6HTCaO0SXQzSqMAAREUq65/9MSwoVWwj1olRISA7vXg7PeUBEbsUARERf9wAlcv6Pp0nqDkCV3BGayK0YgIh8XI2pHTWmDigkICNRJ7oc+pZEBiCiYcEAROTjenp/xseEIECtElsMnSMxzBmAGiw2WKxdgqshGj0YgIh8XEm5c/7P9ORQsYVQn/zVSkQFaQAAlU3sBSJyFwYgIh+3r7IZAOf/eDIOgxG5HwMQkQ+zdTnwVVX3BojJDECeKjHcuTdTZSOPxCByFw74E/mgDbsqADh7FGxdDgSoldhxsh5FZQ2CK6O+uFaCNbVxQ0QiN/GIHqB169YhJSUFWq0WWVlZ2L17d79tDx06hJtvvhkpKSmQJAkFBQUX/ZxEvqqie0glMSyAGyB6sOhgLdRKBaxdDtS1WEWXQzQqCA9AmzZtQl5eHlatWoWSkhJkZGQgNzcXtbW1fbZva2vDmDFj8OSTTyImJsYtz0nkq3om1fbMMSHPpFRIiA/rGQbjPCAidxAegNauXYvly5dj2bJlmDhxItavX4+AgAC89NJLfbafNWsWnn76adx6663QaDRueU4iX9XTA5TEAOTxet6jCgYgIrcQGoBsNhuKi4uRk5PjuqZQKJCTk4OioiKPeU6i0cjc0Ynmtk5IAA9A9QI971FVMydCE7mD0ABUX18Pu90OvV7f67per4fBYBix57RarTCbzb1uRKNdz1CKPkQLrZ9ScDV0IQndGyIazR1ot9kFV0Pk/YQPgXmC/Px86HQ61y0xMVF0SUTDricA9SyxJs8WolUhWKOCQwYO15hEl0Pk9YQGoMjISCiVShiNxl7XjUZjvxOch+M5V6xYAZPJ5LpVVlYO6XsTeRPO//EukvT1ROgDZxmAiC6W0ACkVqsxY8YMFBYWuq45HA4UFhYiOzt7xJ5To9EgJCSk141oNLM7ZNdckp6zpsjzMQARuY/wjRDz8vKwZMkSzJw5E7Nnz0ZBQQEsFguWLVsGAFi8eDHi4+ORn58PwDnJ+fDhw66vq6qqUFpaiqCgIKSlpQ3oOYl8ncHUgU67DK2fApHBfa+mJM+TEOoMq/vPNosthGgUEB6AFi1ahLq6OqxcuRIGgwGZmZnYsmWLaxJzRUUFFIqvO6qqq6sxbdo0179Xr16N1atXY968edi2bduAnpPI11U0WgA4h78U3ADRa/SsBDtVZ4G5oxMhWj/BFRF5L0mWua/6t5nNZuh0OphMJg6H0ah0w3Nf4sBZE66aEI2rxvMPA2/y9EdH0dTWiQ0/zcKctEjR5RB5lMH8/uYqMCIf1LMCLDk8UHAlNFjx3XO2DlRxHhDRxRhSADp16pS76yCiEVJr7kATN0D0WgmhPROhm8UWQuTlhhSA0tLScOWVV+L1119HR0eHu2siomFUUtEEgBsgequelWD7K9kDRHQxhhSASkpKMHXqVOTl5SEmJgY///nPedo6kZcoqWgGwP1/vFV8qD8kyXkkRkMrT4YnGqohBaDMzEw888wzqK6uxksvvYSamhrMnTsXkydPxtq1a1FXV+fuOonITYrLnT1ASREMQN5I66fEmEjn3C3uB0Q0dBc1CVqlUmHhwoV488038dRTT+HkyZN4+OGHkZiYiMWLF6OmpsZddRKRG1i77Piqe/Ise4C8V0ZCKAAGIKKLcVEBaO/evfjlL3+J2NhYrF27Fg8//DDKysqwdetWVFdX48Ybb3RXnUTkBoeqzbB1ORCgViIiUC26HBqiKQk6AJwITXQxhrQR4tq1a/Hyyy/j2LFjuPbaa/Haa6/h2muvdW1YmJqaildeeQUpKSnurJWILlJJz/BXeAAkboDotaZ29wDtP2uCLMt8L4mGYEgB6Pnnn8dPfvITLF26FLGxsX22iY6Oxt///veLKo6I3KtnBRiHv7zbpLgQqBQS6lutqDF1IC6U2xkQDdaQAtDWrVuRlJTU64gKAJBlGZWVlUhKSoJarcaSJUvcUiQRuUdJeTMAToD2dlo/Jcbqg3G4xowDZ5sZgIiGYEhzgC655BLU19efc72xsRGpqakXXRQRuV91czsM5g4oFZLrUE3yXlNd84A4EZpoKIYUgPo7Pqy1tRVarfaiCiKi4dGz/H1ibAjUKp6C4+2mciUY0UUZ1BBYXl4eAECSJKxcuRIBAV//FWm327Fr1y5kZma6tUAico+e+T/Tk0LFFkJuMfUbK8E4EZpo8AYVgPbt2wfA2QP01VdfQa3+ehmtWq1GRkYGHn74YfdWSERu0bMCbHpyGCxWu+Bq6GKNiwmGRqWAuaMLZxrakBrJg22JBmNQAeizzz4DACxbtgzPPPPMBY+aJyLP0NFpx6FqMwBgelIYvjhx7hw+8i5+SgUmxoVgX0UzDpxtZgAiGqQhTQR4+eWXGX6IvMiBsyZ0OWREB2t4AvwoMjWeE6GJhmrAPUALFy7EK6+8gpCQECxcuPC8bd9+++2LLoyI3Ofr+T9hnCsyijgnQpdzR2iiIRhwANLpdK4PTp1ON2wFEZH79awAm5EcJrgScqeMROdn8cEqM7rsDqiUXN1HNFADDkAvv/xyn18TkWdzOGTsPdMIAJiRwgA0moyJDEKQRoVWaxdO1rVifAynJhAN1JD+XGhvb0dbW5vr3+Xl5SgoKMDHH3/stsKIyD1O1rWiqa0T/n5KTIln7+1oolBImBzvDD0HKjkPiGgwhhSAbrzxRrz22msAgObmZsyePRtr1qzBjTfeiOeff96tBRLRxdl1urv3JzkMfhwiGXVcGyJWNQutg8jbDOnTsKSkBJdffjkA4K233kJMTAzKy8vx2muv4dlnn3VrgUR0cXZ3B6DZqeGCKyF32bCrwnUzt3cCAD47Wue6RkQXNqQA1NbWhuDgYADAxx9/jIULF0KhUODSSy9FeXm5WwskoqGTZRm7TjUAYAAarRLCnDvyG0wd6LI7BFdD5D2GFIDS0tKwefNmVFZW4qOPPsLVV18NAKitreX+QEQepLyhDbUtVqiVCmQmhoouh4ZBWIAfAtRK2GUZBnOH6HKIvMaQAtDKlSvx8MMPIyUlBVlZWcjOzgbg7A2aNm2aWwskoqHrGf7KSNRB66cUXA0NB0mSXJtbnm1qF1wNkfcY1FEYPW655RbMnTsXNTU1yMjIcF2/6qqrcNNNN7mtOCK6OLs4/8cnxIf647ixFVUMQEQDNqQABAAxMTGIiYnpdW327NkXXRARuc/uM875P1mpEYIroeHUMw/obHPbBVoSUY8hBSCLxYInn3wShYWFqK2thcPRe+LdqVOn3FIcEQ1dZWMbKhvboVRImM4doEe1+O4hsFqzFbYuToQmGoghBaCf/vSn+Pzzz3HHHXcgNjaWZwsReZgNuypcuz/Hh/rj3dJqwRXRcArR+iFEq4K5owtVzRwGIxqIIQWgDz/8EO+//z4uu+wyd9dDRG5ysq4VAHBJVJDgSmgkxIcFwFxjRlUTh8GIBmJIq8DCwsIQHs5JlUSeSpZlnKqzAAAuiQ4UXA2NBNdKMPYAEQ3IkALQ73//e6xcubLXeWBE5DmMLVa0Wrvgp5SQ1D1Blka3hFBnAOJKMKKBGdIQ2Jo1a1BWVga9Xo+UlBT4+fn1ur+kpMQtxRHR0JTVOoe/UiICoeL5Xz6hZyJ0g8UGU1sndAF+F3gEkW8b0ifjggUL8NBDD+Hhhx/GLbfcghtvvLHXbbDWrVuHlJQUaLVaZGVlYffu3edt/+abb2L8+PHQarWYMmUKPvjgg173t7a24p577kFCQgL8/f0xceJErF+/ftB1EXmrMs7/8TkBahXCA9UAeDAq0UAMqQdo1apVbitg06ZNyMvLw/r165GVlYWCggLk5ubi2LFjiI6OPqf9jh07cNtttyE/Px/XX389NmzYgAULFqCkpASTJ08GAOTl5eHTTz/F66+/jpSUFHz88cf45S9/ibi4ONxwww1uq53IE3XZHThd3z3/hwHIp8SH+qPRYsOBsyZcnh4luhwijzbkvvHm5mb87W9/w4oVK9DY6FxuW1JSgqqqqkE9z9q1a7F8+XIsW7bM1VMTEBCAl156qc/2zzzzDObPn49HHnkEEyZMwO9//3tMnz4dzz33nKvNjh07sGTJElxxxRVISUnBz372M2RkZFywZ4loNDhQZYK1ywF/PyViQ7Wiy6ER1DMRurSyWWwhRF5gSAHowIEDGDt2LJ566imsXr0azc3NAIC3334bK1asGPDz2Gw2FBcXIycn5+uCFArk5OSgqKioz8cUFRX1ag8Aubm5vdrPmTMH7777LqqqqiDLMj777DMcP37cdWjrt1mtVpjN5l43Im+1/XgdAOCSqEAouEeXT0kKd054LylvgizLgqsh8mxDCkB5eXlYunQpTpw4Aa32678wr732Wmzfvn3Az1NfXw+73Q69Xt/rul6vh8Fg6PMxBoPhgu3/8pe/YOLEiUhISIBarcb8+fOxbt06fOc73+nzOfPz86HT6Vy3xMTEAb8GIk+z7ZgzAI3VBwuuhEZafKg/VAoJDRYbzjRwlS7R+QwpAO3Zswc///nPz7keHx/fb3AZSX/5y1+wc+dOvPvuuyguLsaaNWtw991345NPPumz/YoVK2AymVy3ysrKEa6YyD2aLDbsP9sMAEhnAPI5KqUC8d3L4Xt2Aieivg1pErRGo+lzmOj48eOIihr4xLvIyEgolUoYjcZe141G4zkHrfaIiYk5b/v29nY89thjeOedd3DdddcBAKZOnYrS0lKsXr36nOGzntej0WgGXDeRp9p+og6yDMSEaKHz5zJoX5QcEYDyxjYUlzfhBzPZm03UnyH1AN1www343e9+h87OTgCAJEmoqKjAr3/9a9x8880Dfh61Wo0ZM2agsLDQdc3hcKCwsBDZ2dl9PiY7O7tXewDYunWrq31nZyc6OzuhUPR+aUql8pxDW4lGm8+P9wx/cfWXr0qOcO78vYc9QETnNaQAtGbNGrS2tiIqKgrt7e2YN28e0tLSEBwcjD/+8Y+Deq68vDy8+OKLePXVV3HkyBHcddddsFgsWLZsGQBg8eLFvSZW33///diyZQvWrFmDo0eP4je/+Q327t2Le+65BwAQEhKCefPm4ZFHHsG2bdtw+vRpvPLKK3jttddw0003DeXlEnkFh0PG9uP1ADj85ct6JkKX1VnQZLEJrobIcw1pCEyn02Hr1q343//+h/3796O1tRXTp0/vc3jpQhYtWoS6ujqsXLkSBoMBmZmZ2LJli2uic0VFRa/enDlz5mDDhg14/PHH8dhjjyE9PR2bN2927QEEABs3bsSKFStw++23o7GxEcnJyfjjH/+IX/ziF0N5uURe4XCNGfWtVgSqlUiO4PEXvipQo8IlUYEoq7OguLwJORP1F34QkQ+S5EGulXQ4HHjllVfw9ttv48yZM5AkCampqbjllltwxx13QBoFy27NZjN0Oh1MJhNCQkJEl0M0IM99egKrPz6O703U48px524iSr5jf2UzNu2txC/mXYJHrxkvuhyiETOY39+DGgKTZRk33HADfvrTn6KqqgpTpkzBpEmTUF5ejqVLl3KIiUigT47UAgCuGMcdgH3djJQwAEBxOecBEfVnUENgr7zyCrZv347CwkJceeWVve779NNPsWDBArz22mtYvHixW4skovOra7G6lr/nTNCjsDsMkW+alRIOANhfaUJHpx1aP6Xgiog8z6B6gP75z3/iscceOyf8AMB3v/tdPProo3jjjTfcVhwRDcxnR2shy8CUeB30ITz+wtelRAQgOlgDm92Bkoom0eUQeaRBBaADBw5g/vz5/d5/zTXXYP/+/RddFBENztYjzr2xciZwwis5tybJviQCALDzFIfBiPoyqADU2Nh4zjEU36TX69HUxL82iEZSR6cdX55wLn+/agInP5PTpWO6A1BZg+BKiDzToAKQ3W6HStX/tCGlUomurq6LLoqIBm5HWT3aO+2I1WkxKY6rFskpuzsA7atsQrvNLrgaIs8zqEnQsixj6dKl/R4bYbVa3VIUEQ1cz+qvqyZEj4ptKMg9kiMCEKvTosbUgeLyJsxNjxRdEpFHGVQAWrJkyQXbcAUY0chxOGR8ctg5/+cqzv+hb5AkCdljIvD2vioUnapnACL6lkEFoJdffnm46iCiIdhX2YzaFiuCNCrM6Z70StTj0p4AxHlAROcY0llgROQZPjpkAAB8d3w0NCru9UK99awEO3DWBIuV8zOJvokBiMhLybKMLQedAWj+5BjB1ZAnSgwPQHyoP7ocMnbzdHiiXhiAiLzUUUMLKhrboFEpMG8sj7+gvl3ePfdn+/E6wZUQeRYGICIv1dP7c3l6FAI1g5rORz6kJxwzABH1xgBE5KV65v9w+IvOZ05aJJQKCWV1FpxtahNdDpHHYAAi8kJn6i04amiBUiEhh7s/03no/P2QmRgKANh+vF5sMUQehP3mRF7oyQ+PAgBSIwLxwVcGwdWQp/tOehSKy5uw/XgdfpSVJLocIo/AHiAiL3So2gQAmMijL2gA5o1zzgP6X1k9uuwOwdUQeQYGICIvYzR3oLKpHQAwMZYBiC5sSrwOoQF+aOnoQmlls+hyiDwCAxCRl/m4e/JzUngAQvz9BFdD3kCpkDA3zbkcftsxrgYjAjgHiMjrbOkOQDz5nfqzYVfFOdf8/Zw7hb9VfBYP544b6ZKIPA57gIi8SHObDTtPOXf05fAXDcY4fTAkAAZzByobuRyeiAGIyIt8cqQWdoeMmBAtIoI0osshLxKgUSE5IhAAUHjEKLgaIvEYgIi8SM/8H67+oqGYEBsMACg8Wiu4EiLxGICIvES7zY7tJ5wTWDn8RUMxofu/m52nGmDu6BRcDZFYnARN5IH6msR6uNqEjk4HwgL8EKvTCqiKvF1kkAZRQRrUtVqx/Xgdrp8aJ7okImHYA0TkJQ7XmAE4e38kSRJcDXmrnmGwrYc5D4h8GwMQkRewO2QcqWkBAEyM0wmuhrxZzzDYp0drYe2yC66GSBwGICIvcKbBgvZOOwLUSiSFB4guh7xYYngAooM1aOnowo6TDaLLIRKGAYjIC/QMf02ICYFSweEvGjqFJOGayTEAgA++qhFcDZE4DEBEHk6WZRyp7p7/w+Xv5AbXTIkFAHx82IhOHo5KPooBiMjDVZs60NzeCbVSgbToINHl0CgwKyUckUEamNo7UVTGYTDyTQxARB7ucLUJAJCuD4Kfkj+ydPGUCgnzJ+sBAB8e5DAY+SaP+DRdt24dUlJSoNVqkZWVhd27d5+3/Ztvvonx48dDq9ViypQp+OCDD85pc+TIEdxwww3Q6XQIDAzErFmzUFFx7t4qRJ7um8vfidzl2snOYbCPDhnRxWEw8kHCA9CmTZuQl5eHVatWoaSkBBkZGcjNzUVtbd9bte/YsQO33XYb7rzzTuzbtw8LFizAggULcPDgQVebsrIyzJ07F+PHj8e2bdtw4MABPPHEE9BquXkceZeGViuMZisUEjA+hgGI3Gd2ajgiAtVotNjw5cl60eUQjThJlmVZZAFZWVmYNWsWnnvuOQCAw+FAYmIi7r33Xjz66KPntF+0aBEsFgvee+8917VLL70UmZmZWL9+PQDg1ltvhZ+fH/7xj38MqSaz2QydTgeTyYSQEP7SoZHXsxP0Fyfq8OFBA9KigvCTuamCq6LR4kdZSQCAVf85iFeLynHTtHj830WZYosicoPB/P4W2gNks9lQXFyMnJwc1zWFQoGcnBwUFRX1+ZiioqJe7QEgNzfX1d7hcOD999/H2LFjkZubi+joaGRlZWHz5s391mG1WmE2m3vdiDzB4e7VXxO4+ouGwY3T4gEAHx0yoM3WJbgaopElNADV19fDbrdDr9f3uq7X62EwGPp8jMFgOG/72tpatLa24sknn8T8+fPx8ccf46abbsLChQvx+eef9/mc+fn50Ol0rltiYqIbXh3RxbFYu1DR2AYAmBATLLgaGo2mJYYiOSIAbTY7j8YgnyN8DpC7ORzOyXw33ngjHnzwQWRmZuLRRx/F9ddf7xoi+7YVK1bAZDK5bpWVlSNZMlGfjhtbIAOI1WkRGqAWXQ6NQpIk4cYM54Go/ymtFlwN0cgSGoAiIyOhVCphNPb+y8NoNCImJqbPx8TExJy3fWRkJFQqFSZOnNirzYQJE/pdBabRaBASEtLrRiTaUYPz7K/x7P2hYXRDpnMYbPvxOjRabIKrIRo5QgOQWq3GjBkzUFhY6LrmcDhQWFiI7OzsPh+TnZ3dqz0AbN261dVerVZj1qxZOHbsWK82x48fR3JysptfAdHwsDtkHDc6A9A4rv6iYZQWHYTJ8SHocsh4/wB7gch3qEQXkJeXhyVLlmDmzJmYPXs2CgoKYLFYsGzZMgDA4sWLER8fj/z8fADA/fffj3nz5mHNmjW47rrrsHHjRuzduxcvvPCC6zkfeeQRLFq0CN/5zndw5ZVXYsuWLfjvf/+Lbdu2iXiJRIN2psECa5cDgWolEsL8RZdDo0zPKsMeSWEBOFhlxotfnIZSoXCtEiMazYQHoEWLFqGurg4rV66EwWBAZmYmtmzZ4proXFFRAYXi646qOXPmYMOGDXj88cfx2GOPIT09HZs3b8bkyZNdbW666SasX78e+fn5uO+++zBu3Dj8+9//xty5c0f89RENxTFDT+9PMBQSDz+l4TU1IRQfHjSgorGNw2DkM4TvA+SJuA8QiTbzD5+gvtWK22YnYUq8TnQ55AP+/uUplNVZcPVEPV5YPFN0OURD4jX7ABHRuU7XW1Df6tz9OZ2Hn9IIyUwMBQCUVjaDfxeTL2AAIvIwnx51HgOTGhkIrZ9ScDXkKybF6aBSSKhtsbrOnyMazRiAiDzMp0ed2zzw7C8aSVo/JcZ1b7mweV+V4GqIhh8DEJEHaenoxK5TjQC4/w+NvOlJYQCAd/ZVo5MnxNMoxwBE5EG+OFGPLoeMyCANIoI0osshHzNWH4xAtRL1rVZsP14nuhyiYcUARORBCo845/+w94dEUCok12ToN/eeFVsM0TBjACLyEHaHjG3HGIBIrOnJzmGwwqNG7glEoxoDEJGH2H+2GQ0WG4K1KiRHBIouh3xUrM4fk+ND0GmX8W4pJ0PT6MUAROQhPu0e/vrO2CgoFdz9mcT5wYxEAMCbxRwGo9GLAYjIQxR27/+TMyFacCXk627IiIOfUsKhajMOV3NPIBqdGICIPEB1czuO1JihkIB5YxmASKywQDVyJjjPY3yLvUA0SjEAEXmAnt6f6UlhCA9UC66GCPjBzAQAwObSKti6uCcQjT4MQEQe4NMjzt2fr+r+q5tItO+kRyEySINGi821OpFoNGEAIhKszdaF/5U1AACu4vwf8hAqpQILp8cD4GRoGp1Uogsg8nU7TjbA1uVAQpg/T38nj7BhVwUAwL/7MN7CI0a8sP0UgjTOXxk/ykoSVhuRu7AHiEiwnvk/V42PhiRx+Tt5Dn2IFglh/nDIQGlls+hyiNyKAYhIIFmWXae/f5fzf8gD9RyQWlLeBFmWBVdD5D4MQEQCHao2w2i2IkCtRFZquOhyiM6RkRAKpUKCwdyBGlOH6HKI3IYBiEigT7uHv+amRULbPd+CyJP4q5WYGBsCACgubxJcDZH7MAARCeSa/8PVX+TBZnQfkFpa2YwuO/cEotGBAYhIkLoWK/Z3Tyy9cjwDEHmutOgghGhVaO+044ihRXQ5RG7BAEQkyGfdm8tlJOgQHawVXA1R/xSShGndk6GLyxsFV0PkHtwHiEiADbsq8MaucgBAZLDGte8KkaeamRyGz4/X4YSxFWeb2pAQFiC6JKKLwh4gIgE67Q6cMLYCAMbrQwRXQ3RhEUEajIkKhAzgzb3cGZq8HwMQkQAna1thszug8/dDXCiHv8g7zEp2btXw5t5K2B3cE4i8GwMQkQCHq80AgImxIdz9mbzGxLgQ+PspUW3qwPYTdaLLIbooDEBEI6zL7sARQ3cAiuPwF3kPP6UC05JCAQCbdleKLYboIjEAEY2wPWea0GazI0CtREpEoOhyiAZlZopzGOyTI0bUtVgFV0M0dAxARCPso0MGAMD4mBAoFRz+Iu8SE6LFtKRQdDlk/LuEk6HJezEAEY0gWZbxcXcAmsThL/JSt85KBABs2lPJA1LJazEAEY2gA2dNqDZ1wE8pIS06SHQ5RENy/dQ4BKqVOF1vwa7T3BiRvBMDENEIeu9ANQDn8Jefkj9+5J0CNSrckBkHANi4m5t4knfyiE/gdevWISUlBVqtFllZWdi9e/d527/55psYP348tFotpkyZgg8++KDftr/4xS8gSRIKCgrcXDXR4DgcMt4/UAMAmJqgE1wN0cVZNCsJAPDBQQMaLTbB1RANnvAAtGnTJuTl5WHVqlUoKSlBRkYGcnNzUVtb22f7HTt24LbbbsOdd96Jffv2YcGCBViwYAEOHjx4Ttt33nkHO3fuRFxc3HC/DKILKqloQrWpA0EaFcbqg0WXQ3RRMhJ0mBwfAluXA5v2cEk8eR/hAWjt2rVYvnw5li1bhokTJ2L9+vUICAjASy+91Gf7Z555BvPnz8cjjzyCCRMm4Pe//z2mT5+O5557rle7qqoq3HvvvXjjjTfg5+c3Ei+F6Lze6+79+d5EPYe/yOtJkoTFl6YAAF7fWc6docnrCP0UttlsKC4uRk5OjuuaQqFATk4OioqK+nxMUVFRr/YAkJub26u9w+HAHXfcgUceeQSTJk26YB1WqxVms7nXjcid7A4Z73/lDEDXT40VXA2Re9yQGYfQAD9UNbfjs6N999oTeSqhAai+vh52ux16vb7Xdb1eD4PB0OdjDAbDBds/9dRTUKlUuO+++wZUR35+PnQ6neuWmJg4yFdCdH67TzeirsWKEK0Kl6dHiS6HyC20fkr8cKbz8/K1neWCqyEaHJXoAtytuLgYzzzzDEpKSgZ8xtKKFSuQl5fn+rfZbGYIIrf6T2kVAGD+5BioVRz+Iu+2YdfXK79CtH6QAGw/XodnC08gMkiDH2UliSuOaICEfhJHRkZCqVTCaDT2um40GhETE9PnY2JiYs7b/osvvkBtbS2SkpKgUqmgUqlQXl6Ohx56CCkpKX0+p0ajQUhISK8bkbt0dNpdq79umpYguBoi9woPVLsm9e861SC4GqKBExqA1Go1ZsyYgcLCQtc1h8OBwsJCZGdn9/mY7OzsXu0BYOvWra72d9xxBw4cOIDS0lLXLS4uDo888gg++uij4XsxRP346JABLdYuxIf6Iys1XHQ5RG536Rjnf9fFFU2wdTkEV0M0MMKHwPLy8rBkyRLMnDkTs2fPRkFBASwWC5YtWwYAWLx4MeLj45Gfnw8AuP/++zFv3jysWbMG1113HTZu3Ii9e/fihRdeAABEREQgIiKi1/fw8/NDTEwMxo0bN7IvjgjA2yXO4a+bp8dDwbO/aBRK1wcjPFCNRosN+yubRZdDNCDCA9CiRYtQV1eHlStXwmAwIDMzE1u2bHFNdK6oqIBC8XVH1Zw5c7BhwwY8/vjjeOyxx5Ceno7Nmzdj8uTJol4CUb+M5g58caIOALBwOoe/aHRSSBKyUsPx4UEDdp5ugCzLA56DSSSKJPMku3OYzWbodDqYTCbOB6KL8tfPy5D/4VHMTA7DW3fNcV3/5iRSotGgzdaFJz88ii6HjLd+kY2ZKRzupZE3mN/fXI5CNExkWca/9jp3yGXvD412AWoVMhJDAQB/++K02GKIBoABiGiY7DrdiLI6CwLVStfBkUSj2dy0SADAR4cNOFXXKrgaovMTPgeIaDTasKsCG/c4h7kmxunwbmm14IqIhp8+RIvxMcE4amjB3748jT/dNEV0SUT9Yg8Q0TBotXbhUJXzSBUufSdf0rPT+VvFZ1HXYhVcDVH/GICIhkFJeRPssoyEMH/EhfqLLodoxKREBCAzMRS2LgdeKzojuhyifjEAEbmZ3SFj95lGAMBsroQhHyNJEn7+nTEAgNeKymGxdgmuiKhvDEBEblZ4xIhGiw3+fkpMTQgVXQ7RiLt6UgxSIgJgau/Epj2Vossh6hMDEJGb/f1L5xLgWSnhPPiUfJJSIWF5dy/Q3788jU47j8cgz8NPZyI3+uqsCbtON0IhAdmXRFz4AUSj1M3TExARqEZVczs++KpGdDlE52AAInKjv395CgAwJV4Hnb+f4GqIxNH6KbF0TgoAYP3np8BDB8jTcB8gIjcxmDrw3gHnX7qXdW8IR+SLeo568VcroVYpcKTGjCc2H8LEOOfRBD/KShJZHhEA9gARuc0L20+hyyFjdmo4EsICRJdDJFyAWoXsMc6h4MKjRvYCkUdhACJyg/pWKzbsLgcA3HNlmuBqiDzH5WmRUKsUqDF14EiNWXQ5RC4MQERu8LcvTqOj04GMBB0uT+fwF1GPAI0Kc1y9QLXsBSKPwQBEdJGa22z4R/eOt/d+Nx2SJIktiMjDzE2LhKa7F+gwe4HIQzAAEV2kv395GhabHRNiQ3DVhGjR5RB5nACNyrUtROGRWjgc7AUi8bgKjGgIela5tHR0Yv3nZQCAaYmh+Odu7npL1Je5aZEoKmuAwdyBjw8bMH9yrOiSyMexB4joInx2rA6dduehp5O6l/gS0bkC1CrM6e4FKvjkBHuBSDgGIKIharTYsOe089DT3EkxnPtDdAGXdc8FOmpowYcHDaLLIR/HAEQ0RB8fNsAuy0iPDsIlUUGiyyHyeAFqlWuT0DVbj6GLZ4SRQAxARENwut6CA2dNkODs/SGigZmbFomwAD+cqrPgzeKzosshH8YARDRIXXYH/ru/GgAwMyUccaH+gisi8h5aPyXu+W46AKDgk+Not9kFV0S+igGIaJA27K6AwdwBfz8lrp6oF10Okdf58aVJiA/1h9FsxSs7zoguh3wUl8ETDUJtSwdWf3QMAPC9iXoEavgjRDRY/y6uQvYlEXir+CyeKTwOtVIBf7XSdT8PS6WRwB4gogGSZRn/552DMHd0IT7UH7NTw0WXROS1MhNDoQ/RoKPTgc+P14ouh3wQAxDRAL27vxpbDxvhp5Rw8/QEKLjsnWjIFJKE3InOBQQ7yhpgau8UXBH5GgYgogGobenAqncPAXCe9xWj0wquiMj7jYsJRnJEALocMgqPGEWXQz6GAYjoAuwOGQ9sLEVzWycmxobgrisuEV0S0aggSRLmd28jUVzehNqWDsEVkS9hACK6gOc+PYkdZQ0IUCvx7G3T4Kfkjw2RuyRHBGJCTDBkAFsPsxeIRg4/yYnOY8fJejxTeBwA8IcFk5EWzR2fidzt6kkxkAAcqjajsrFNdDnkIxiAiPpxpt6CX24ogUMGfjAjAQunJ4guiWhU0odoMS0pDACw5ZABssyDUmn4MQAR9cHU3ok7X92D5rZOZCSG4vcLJosuiWhUy5kQDZVCwul6C7YdqxNdDvkAjwhA69atQ0pKCrRaLbKysrB79+7ztn/zzTcxfvx4aLVaTJkyBR988IHrvs7OTvz617/GlClTEBgYiLi4OCxevBjV1dXD/TJolOjotOOu14tRVmdBrE6LF++YAa2f8sIPJKIhCw1QI3tMBADgjx8c4UGpNOyEB6BNmzYhLy8Pq1atQklJCTIyMpCbm4va2r43xtqxYwduu+023Hnnndi3bx8WLFiABQsW4ODBgwCAtrY2lJSU4IknnkBJSQnefvttHDt2DDfccMNIvizyUrYuB375Rgl2lDVArVLg5ukJ+ORILTbsquh1IyL3u2JcNALUSpysbcU/91SKLodGOUkWPNialZWFWbNm4bnnngMAOBwOJCYm4t5778Wjjz56TvtFixbBYrHgvffec1279NJLkZmZifXr1/f5Pfbs2YPZs2ejvLwcSUkX3mLdbDZDp9PBZDIhJCRkiK+MvE2X3YF7/7kPHx40wE8pYcmcFIyJ5KRnopFUdKoB/91fjfBANbY9cgVCtH6iSyIvMpjf30J7gGw2G4qLi5GTk+O6plAokJOTg6Kioj4fU1RU1Ks9AOTm5vbbHgBMJhMkSUJoaGif91utVpjN5l438i0Oh4xH3jqADw8aoFYq8OOsZIYfIgFmp4TjkqhANFpsWPfZSdHl0CgmNADV19fDbrdDr+99orZer4fBYOjzMQaDYVDtOzo68Otf/xq33XZbv2kwPz8fOp3OdUtMTBzCqyFv0zOc9cbOcix6oQjv7KuCQgIWzUpEuj5YdHlEPkmpkPB/rpsAAHj5yzNcFk/DRvgcoOHU2dmJH/7wh5BlGc8//3y/7VasWAGTyeS6VVZy7NlXyLKM97+qwZ4zTZAA/HBmIibEctiTSKQrx0VjblokbHYHntxyVHQ5NEoJDUCRkZFQKpUwGnvv/mk0GhETE9PnY2JiYgbUvif8lJeXY+vWrecdC9RoNAgJCel1I9+w9bARO8oaAAA3T0/A1IRQsQURESTJ2QskScD7B2pQXN4ouiQahYQGILVajRkzZqCwsNB1zeFwoLCwENnZ2X0+Jjs7u1d7ANi6dWuv9j3h58SJE/jkk08QERExPC+AvNpnx2qx7bhzv5EbMuIwPTlMcEVE1GNCbAgWzXROR/jdfw/D4eDmiORewofA8vLy8OKLL+LVV1/FkSNHcNddd8FisWDZsmUAgMWLF2PFihWu9vfffz+2bNmCNWvW4OjRo/jNb36DvXv34p577gHgDD+33HIL9u7dizfeeAN2ux0GgwEGgwE2m03IayTP87cvTrnOHbpmcgwuHcOQTORp8q4ei2CNCvvPmrCRy+LJzYQHoEWLFmH16tVYuXIlMjMzUVpaii1btrgmOldUVKCmpsbVfs6cOdiwYQNeeOEFZGRk4K233sLmzZsxebJzp96qqiq8++67OHv2LDIzMxEbG+u67dixQ8hrJM/yxq5y/OH9IwCcu89enh4luCIi6kt0sBZ5V48FADy15SgaWq2CK6LRRPg+QJ6I+wCNXh98VYO7N5RAloHvpEchd5IekiSJLouIvuFHWV/v19Zld+CG5/6HwzVm/HBmAv58S4bAysjTec0+QEQjaeepBjywsRSy7PyAZfgh8nwqpcJ1Ft+/9p7lhGhyG5XoAohGwlGDGctf2wub3YGrJ+rx+xsnYxPnFBB5pL6Om5mRHIbi8ibcs2EfvvjVlVAp+fc7XRwGIBq1ej5Em9tsWP95GVo6upAcEYDL0iIZfoi8zPxJMThcbUaNqQOvFZXjJ3NTRZdEXo4Rmka1NlsXXt5xBuaOLkQHa7D40hT48S9HIq8TqFEhd5Jzv7e1W4/DaO4QXBF5O/4moFGr0+7Aa0XlqGuxQufvh6VzUuCvVooui4iGaGZKGBLC/NFq7cL/eecguIaHLgYDEI1KXXYHNu6uQEVjG7R+Ciydk4LQALXosojoIigkCQunJcBPKeGTI0ZsLq0SXRJ5MQYgGnVkWcYT/zmEI4YWqBQSFl+aAn2IVnRZROQGMTot7r8qHQDwm3cPo5ZDYTREDEA06jxTeAL/3F0BCcCtsxKREhkouiQicqOfz7sEk+NDYGrvxK/+fYDHZNCQMADRqLJhVwUKPjkBALghMw4T43SCKyIid/NTKrDmB5nQqBTYdqwOL+84I7ok8kJcBk+jxseHDHh881cAgPuuSkcMh72IRqWeLS5yJ8Xg3f3V+NP7R9BosSE+1B9A752kifrDHiAaFfaeacS9/9wHh+wc9nowJ110SUQ0zLJSwzExNgR2WcbG3RVot9lFl0RehAGIvN5Rgxl3vroX1i4HciZE4w8LJvOICyIfIEkSFk6PR2iAHxosNmzaWwEHl8bTAHEIjLzWhl0VqG+x4oUvTqHV2oWk8ADMTYvCv/aeFV0aEY2QALUKP85Kxl+3l+G4sRUfHzLix5cmiy6LvAB7gMhrNVls+Pv/TqPV2oVYnRZLslOgVvE/aSJfExfqj4XTEgAA20/U9XmWGNG38bcFeSWDqQN/+/IUTO2diArWYNllqdzlmciHZSSG4opxUQCAxzd/hS0HawRXRJ6OAYi8Tn2rFbf/bSea2joRHqjGnZelIkjD0VwiX/e9CXrMTA6DQwbu+2cpPj9eJ7ok8mAMQORVas0d+NGLO1FWZ4HO3w93zk1FiL+f6LKIyANIkoQbM+Mxf1IMbHYHfvrqHvYEUb8YgMhrVDa24Qd/LcJxYyv0IRrcOTcVYTzfi4i+QamQ8Oxt03DdlFh02mXcvWEf/rWnUnRZ5IEYgMgrHK424wfri1De0IbEcH+8+fM5iAzSiC6LiDyQWqXAM7dm4pYZCbA7ZPzq3wfw2/8eQpfdIbo08iAMQOTxPj9ehx+s3wGDuQNp0UF48+dzkBQRILosIvJgKqUCf755quvg1Jf/dwZ3/H03akztgisjT8EARB5LlmX87YtT+Mkre2Cx2XHpmHD8+xdzEKPjERdEdGEKhYQHvzcW6388HQFqJYpONSD3/27Hf0qrIHPDRJ/HAEQeyWLtwr3/3Ic/vH8EdoeMhdPi8epPZkMXwAnPRDQ48yfH4r175yIjQQdzRxfu31iKpS/vwZl6i+jSSCBJZgw+h9lshk6ng8lkQkhIiOhyfE5xeRPy/lWK8oY2KCTg2imxyB4TweMtiGhA+jsMtdPuwLrPTuL/fVYGm90BtUqBH2cl464rLkFUMOcUjgaD+f3NzVPIY7Tb7Hj20xP46+dlcMhAqL8fFs1KRHJEoOjSiGgU8FMq8EDOWCgg4b8HqnGithUv/e80/rHzDLLHRODy9CgEalQ8Td5HsAeoD+wBGlmyLGPrYSN++9/DqGp2TlBcOC0ek+N10Ppxd2cicj9ZlnGythVbjxhxtsn5uaNWKZA9JgJP3TyVcw291GB+fzMA9YEBaOTsPdOIp7YcxZ4zTQCA+FB/rPr+RFw9KYbn+RDRsJNlGccMLfjkiBHVpg4AgEoh4dopsVh2WQqmJYUJrpAGg0Ng5NEcDhmfHavFX7efwu7TjQAAjUqBn8xNxb3fTUOAmv9ZEtHIkCQJ42NDMC4mGEdqzPjyZAPONFjw7v5qvLu/GpmJofjR7CRcOzWWR+6MMuwB6gN7gIbH2aY2vF1ShX/trXR1OfspJdwyIwH3XzX2nC5n9gARkQhTE3R4+X9n8N/91bB1b57o76fENZNjcMuMBFw6JgIKBRdleCIOgV0kBiD3kGUZR2pasP1EHT48aMD+ymbXfcFaFTITQzHnkkjoeJYXEXmQnknQdS1W/GtvJf5dchan6r5eMq8P0eC74/XImRCNy9IiOVfRgzAAXSQGoKGram7HrlMN+OJEPb44UY/6VqvrPkkCslLDsWhWIuZPisU7+6oEVkpENDCyLKOyqR0l5U04UNWMjs6vj9TQ+ikwNy0SWakRmJ4ciklxXLwhEgPQRWIAGpguuwNHalqwt7wRe8ubUFLehJruSYQ9/JQSxkQGYWxMMCbFhSBEy94eIvJenXYHkiMCUHikFoXfmDjdQ61UYFJ8CDISQpGuD8JYfTDSo4MQyoObRwQD0EViADqXLMs429SOr6pMOHDWhANnm7H3TJNrfLyHQgJidf5Iiw5CWnQQksMDoFJyw3EiGn1kWYbB3IETxlaUN7ahosECi83eZ9sgjQoRgWqEBaoxNy0SieH+SAgLQGJYAGJDtfDj56RbeN0qsHXr1uHpp5+GwWBARkYG/vKXv2D27Nn9tn/zzTfxxBNP4MyZM0hPT8dTTz2Fa6+91nW/LMtYtWoVXnzxRTQ3N+Oyyy7D888/j/T09JF4OV6v0+5AeUMbTta24GCVGQeqTPjqbDOa2jrPaav1UyApPABJ4YFIjnD+MKtV/EEmotFPkiTE6vwRq/MH4Pzd02ixoaKxDTWmDtS2dKC2xYrmtk60WrvQau1CeWMbSr8xHxL4+g/H+DB/xIf6I0anRaxO2/3cWsTotIgIVHM3fDcTHoA2bdqEvLw8rF+/HllZWSgoKEBubi6OHTuG6Ojoc9rv2LEDt912G/Lz83H99ddjw4YNWLBgAUpKSjB58mQAwJ///Gc8++yzePXVV5GamoonnngCubm5OHz4MLRabm4lyzJM7Z2obu5AdXM7qprbUd3c7gw9da04U29Bl+PcjkGlJCFGp0V8qPOHNDEiANHBGij4Q0lEBEmSEBGkQUSQBtO+cd3aZUddixVNbZ1ostgQGaxGZWM7zja14WxTO6xdDlR1fxb3R6mQoPP3Q4jWDxmJul7hKE7n7wpJXJ02cMKHwLKysjBr1iw899xzAACHw4HExETce++9ePTRR89pv2jRIlgsFrz33nuua5deeikyMzOxfv16yLKMuLg4PPTQQ3j44YcBACaTCXq9Hq+88gpuvfXWC9bkDUNgDocMa5cD1i47LDY7Wjo60dLR5fpfc/fXTRYbGlptqLfY0NBqRX2rFY0WGzrt53/b1UoFooI1iNVpv/6rJETL4SwiIjdyyDIs1i40WWxobOuEub0Tpm/czO2daLF2Dei5/JTdIak7KIX4+yFIo4RaqYBa1X1TKqHxU7iuaVzXFfBTKuCnUkCtlJxfd99c96uc111tlRLUKoXrmieEL68ZArPZbCguLsaKFStc1xQKBXJyclBUVNTnY4qKipCXl9frWm5uLjZv3gwAOH36NAwGA3Jyclz363Q6ZGVloaioqM8AZLVaYbV+vVrJZDIBcP4f6U5FZQ34f5+dhEOW4ZCdPTEOGXBAhtz9b1lG9/3f/BqwO2TYuuzdoUdG57fm3gyFv1oBnb8fdP5qhPn7Qefvh8hgDSKD1Ajx9/tWd6sdtg4LbBf9XYmI6JuUACK1QKRW2f2v3iMVdocDLe3OP2zNHc5Q1PvrTlg67LACqG0DagW8BsDZS6VSSs5gpHCGqZ6g1BOmVArJ9bsle0wE7v5umltr6Pm9PZC+HaEBqL6+Hna7HXq9vtd1vV6Po0eP9vkYg8HQZ3uDweC6v+daf22+LT8/H7/97W/PuZ6YmDiwF0JERESD8l8Ajw3Tc7e0tECn0523jfA5QJ5gxYoVvXqVHA4HGhsbERER4ZZJZ2azGYmJiaisrPTYITU6F98378X3zjvxffNOnvS+ybKMlpYWxMXFXbCt0AAUGRkJpVIJo9HY67rRaERMTEyfj4mJiTlv+57/NRqNiI2N7dUmMzOzz+fUaDTQaDS9roWGhg7mpQxISEiI8P84aPD4vnkvvnfeie+bd/KU9+1CPT89hM5oVavVmDFjBgoLC13XHA4HCgsLkZ2d3edjsrOze7UHgK1bt7rap6amIiYmplcbs9mMXbt29fucRERE5FuED4Hl5eVhyZIlmDlzJmbPno2CggJYLBYsW7YMALB48WLEx8cjPz8fAHD//fdj3rx5WLNmDa677jps3LgRe/fuxQsvvADAuQzxgQcewB/+8Aekp6e7lsHHxcVhwYIFol4mEREReRDhAWjRokWoq6vDypUrYTAYkJmZiS1btrgmMVdUVECh+Lqjas6cOdiwYQMef/xxPPbYY0hPT8fmzZtdewABwK9+9StYLBb87Gc/Q3NzM+bOnYstW7YI2wNIo9Fg1apV5wyzkWfj++a9+N55J75v3slb3zfh+wARERERjTTuakdEREQ+hwGIiIiIfA4DEBEREfkcBiAiIiLyOQxAAqSkpECSpF63J598UnRZ9C3r1q1DSkoKtFotsrKysHv3btEl0Xn85je/Oefnavz48aLLom/Zvn07vv/97yMuLg6SJLnOcewhyzJWrlyJ2NhY+Pv7IycnBydOnBBTLPVyofdu6dKl5/wMzp8/X0yxA8AAJMjvfvc71NTUuG733nuv6JLoGzZt2oS8vDysWrUKJSUlyMjIQG5uLmprRR0zSAMxadKkXj9XX375peiS6FssFgsyMjKwbt26Pu//85//jGeffRbr16/Hrl27EBgYiNzcXHR0dIxwpfRtF3rvAGD+/Pm9fgb/+c9/jmCFgyN8HyBfFRwc3O9xHyTe2rVrsXz5cteGnOvXr8f777+Pl156CY8++qjg6qg/KpWKP1ce7pprrsE111zT532yLKOgoACPP/44brzxRgDAa6+9Br1ej82bN+PWW28dyVLpW8733vXQaDRe8zPIHiBBnnzySURERGDatGl4+umn0dXVJbok6maz2VBcXIycnBzXNYVCgZycHBQVFQmsjC7kxIkTiIuLw5gxY3D77bejoqJCdEk0CKdPn4bBYOj1s6fT6ZCVlcWfPS+xbds2REdHY9y4cbjrrrvQ0NAguqR+sQdIgPvuuw/Tp09HeHg4duzYgRUrVqCmpgZr164VXRoBqK+vh91ud+1G3kOv1+Po0aOCqqILycrKwiuvvIJx48ahpqYGv/3tb3H55Zfj4MGDCA4OFl0eDYDBYACAPn/2eu4jzzV//nwsXLgQqampKCsrw2OPPYZrrrkGRUVFUCqVoss7BwOQmzz66KN46qmnztvmyJEjGD9+PPLy8lzXpk6dCrVajZ///OfIz8/3uq3EiTzFN7vmp06diqysLCQnJ+Nf//oX7rzzToGVEfmGbw5RTpkyBVOnTsUll1yCbdu24aqrrhJYWd8YgNzkoYcewtKlS8/bZsyYMX1ez8rKQldXF86cOYNx48YNQ3U0GJGRkVAqlTAajb2uG41GrxnbJiA0NBRjx47FyZMnRZdCA9Tz82U0GhEbG+u6bjQakZmZKagqGqoxY8YgMjISJ0+eZAAazaKiohAVFTWkx5aWlkKhUCA6OtrNVdFQqNVqzJgxA4WFhViwYAEAwOFwoLCwEPfcc4/Y4mjAWltbUVZWhjvuuEN0KTRAqampiImJQWFhoSvwmM1m7Nq1C3fddZfY4mjQzp49i4aGhl5h1pMwAI2woqIi7Nq1C1deeSWCg4NRVFSEBx98ED/+8Y8RFhYmujzqlpeXhyVLlmDmzJmYPXs2CgoKYLFYXKvCyPM8/PDD+P73v4/k5GRUV1dj1apVUCqVuO2220SXRt/Q2traq1fu9OnTKC0tRXh4OJKSkvDAAw/gD3/4A9LT05GamoonnngCcXFxrj9GSJzzvXfh4eH47W9/i5tvvhkxMTEoKyvDr371K6SlpSE3N1dg1ech04gqLi6Ws7KyZJ1OJ2u1WnnChAnyn/70J7mjo0N0afQtf/nLX+SkpCRZrVbLs2fPlnfu3Cm6JDqPRYsWybGxsbJarZbj4+PlRYsWySdPnhRdFn3LZ599JgM457ZkyRJZlmXZ4XDITzzxhKzX62WNRiNfddVV8rFjx8QWTbIsn/+9a2trk6+++mo5KipK9vPzk5OTk+Xly5fLBoNBdNn9kmRZlkWFLyIiIiIRuA8QERER+RwGICIiIvI5DEBERETkcxiAiIiIyOcwABEREZHPYQAiIiIin8MARERERD6HAYiIiIh8DgMQERER+RwGICIiIvI5DEBERETkcxiAiIiIyOf8fyfUWmI+ic9oAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# check loc/mean and scale/std dev\n",
    "sns.distplot(x.rvs(10000,10000), bins=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17ac189b",
   "metadata": {},
   "source": [
    "## <font color=\"#fe7401\">Hypothesis Testing</font>\n",
    "* Hypothesis Testing is a methodology for evaluating if a claim is acceptable or not, based on data.\n",
    "* In a Hypothesis Testing, a **Null Hypothesis (Ho)** represents currently accepted the state of knowledge, and an **Alternative Hypothesis (Ha)** represents a new claim which challenges the currently accepted state of knowledge.\n",
    "* The null hypothesis and the alternative hypothesis are mutually exclusive.\n",
    "* Steps Involved in Hypothesis Testing\n",
    "    1. Define the null hypothesis and the alternative hypothesis.\n",
    "    2. Select a test statistics whose probability distribution function can be found under the null hypothesis.\n",
    "    3. Collect data.\n",
    "    4. Compute the test statistics from the data and calculate its p-value under the null hypothesis.\n",
    "    5. Null hypothesis is rejected if the p-value is lower than predetermined significance value.\n",
    "* The methods used for performing t-test are shown below.\n",
    "    * `stats.ttest_1samp`: Tests if the mean of a population is a given value.\n",
    "    * `stats.ttest_ind`: Tests if the means of two independent samples are equal.\n",
    "    * `stats.ttest_rel`: Tests if the means of two paired samples are equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2b03b547",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4.6096766186175335 1.2053870608536614e-05\n"
     ]
    }
   ],
   "source": [
    "# Example 1\n",
    "'''\n",
    "Consider a normal population with mean 0.8 and standard deviation 0.5.\n",
    "Define the null hypothesis as Mean of the population is 1.0.\n",
    "Let's calculate t-statistic and p-value\n",
    "'''\n",
    "mu, sigma = 0.8, 0.5\n",
    "X = stats.norm(mu, sigma)\n",
    "\n",
    "# Deriving a sample\n",
    "n = 100\n",
    "X_sample = X.rvs(n)\n",
    "\n",
    "# Computing test statistic\n",
    "t, p = stats.ttest_1samp(X_sample, 1.0)\n",
    "print(t, p)\n",
    "\n",
    "# Since p-value is very low and less than the significance level 0.05, \n",
    "# we can reject the null hypothesis and infer that the mean of the population is not 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "81918edd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.734695496476908 0.08435093505384637\n"
     ]
    }
   ],
   "source": [
    "# Example 2\n",
    "'''\n",
    "Let's consider another problem, where the null hypothesis states that the population means of two random variables are equal.\n",
    "The below example derives two samples from different populations and verifies the claim that their population means are equal.\n",
    "'''\n",
    "X1 = stats.norm(0.25, 1.0)\n",
    "X2 = stats.norm(0.50, 1.0)\n",
    "\n",
    "X1_sample = X1.rvs(100)\n",
    "X2_sample = X2.rvs(100)\n",
    "\n",
    "t, p = stats.ttest_ind(X1_sample, X2_sample)\n",
    "print(t, p)\n",
    "\n",
    "# Since p-value is very low and less than the significance level 0.05, \n",
    "# we can reject the null hypothesis and state that population means of both samples differ."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "003ab7c7",
   "metadata": {},
   "source": [
    "## <font color=\"#fe7401\"> Statistical Modelling </font>\n",
    "* A Statistical Model is a mathematical equation, which explains the relationship between dependent variables (Y) and independent variables (X).\n",
    "* In general, a model is written as `Y = f(X)`\n",
    "* However, in reality, an element of uncertainty is expected due to factors such as measurement noise. Hence the aforementioned equation can be rewritten as `Y = f(X) + e` where 'e' is residual error\n",
    "* The simplest model is a *linear model* represented as `Y = B0 + B1*X + e`, where the coefficients, B0 and B1 are the parameters of the model and e is normally distributed residual error.\n",
    "* A linear regression model assumes that residuals are independent and normally distributed.\n",
    "* The model is fitted to data using ordinary least squares approach.\n",
    "* Once a model is chosen, **design matrices** y and X are constructed, and the regression problem is written, in matrix form, as `y = XB + e`, where y is the vector of dependent variables, X is the vector of independent variables, B is a vector of coefficients, and e is the residual (error)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2952f205",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[[  1.   6.  11.  66.]\n",
      " [  1.   7.  12.  84.]\n",
      " [  1.   8.  13. 104.]\n",
      " [  1.   9.  14. 126.]\n",
      " [  1.  10.  15. 150.]]\n"
     ]
    }
   ],
   "source": [
    "# The below example shows calculation of design matrices, y, and X, \n",
    "# for the considered linear model Y = B0 + B1*X1 + B2*X2 + B3*X1*X2.\n",
    "\n",
    "y = np.array([1, 2, 3, 4, 5])\n",
    "x1 = np.array([6, 7, 8, 9, 10])\n",
    "x2 = np.array([11, 12, 13, 14, 15])\n",
    "X = np.vstack([np.ones(5), x1, x2, x1*x2]).T  # here T is for transpose\n",
    "\n",
    "print(y)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e4792a9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5. 6.]\n",
      " [1. 1.]]\n",
      "Transpose:\n",
      " [[5. 1.]\n",
      " [6. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# vstack stacks arrays vertically and returns np.ndarray\n",
    "\n",
    "a = np.array([5,6])\n",
    "b = np.ones(2)\n",
    "c = np.vstack([a, b])\n",
    "\n",
    "print(c)\n",
    "print(\"Transpose:\\n\", c.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80def414",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> Design Matrices with patsy </font>\n",
    "\n",
    "* `patsy`, a python library, allows defining a model in simpler easily.\n",
    "* It also constructs relevant design matrices, automatically, using `patsy.dmatrices` function.\n",
    "* patsy.dmatrices takes a formula (in string form) as a *first argument*, and a dictionary-like object with data arrays for the response variables as *second arguments*.\n",
    "* Let's understand few patsy formulae provided below.\n",
    "    * `y ~ x` : y is linearly dependent on x. ~ symbol separates dependent variable from independent variable terms. It is also equivalent to `y ~ 1 + x`.\n",
    "    * `y ~ x1 + x2` : y is a linear combination of x1 and x2. + sign is used to denote the union of terms.\n",
    "    * `y ~ x1*x2` : `x1*x2` is an interaction term that includes all lower order terms. Hence formula is equivalent to `y ~ 1 + x1 + x2 + x1*x2`.\n",
    "    * `y ~ np.log(x1)`: Often numpy functions can be used to transform terms in the expression.\n",
    "    * `y ~ I(x1 + x2)`: `I` is the identify function, used to escape arithmetic expressions and are evaluated.\n",
    "    * `y ~ C(x1)`: Treats the variable x1 as a categorical variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2fafe5b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [2.]\n",
      " [3.]\n",
      " [4.]\n",
      " [5.]]\n",
      "[[  1.   6.  11.  66.]\n",
      " [  1.   7.  12.  84.]\n",
      " [  1.   8.  13. 104.]\n",
      " [  1.   9.  14. 126.]\n",
      " [  1.  10.  15. 150.]]\n"
     ]
    }
   ],
   "source": [
    "import patsy\n",
    "\n",
    "y = np.array([1, 2, 3, 4, 5])\n",
    "x1 = np.array([6, 7, 8, 9, 10])\n",
    "x2 = np.array([11, 12, 13, 14, 15])\n",
    "data = {'y':y, 'x1':x1, 'x2':x2}\n",
    "\n",
    "y, X = patsy.dmatrices('y ~ 1 + x1 + x2 + x1*x2', data)\n",
    "\n",
    "print(y)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bec75a79",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> Example Datasets </font>\n",
    "* `statsmodels` contain few popular example datasets, which can be used to explore various utilities of the package.\n",
    "* The example data sets are available in `datasets` module.\n",
    "* Each dataset is associated with special variables like SOURCE, DESCSHORT, DESCLONG, that provide more info about the dataset.\n",
    "* A dataset can be loaded using `load` function, and its data can be accessed using `dat`a attribute in the form of Numpy's recarray.\n",
    "* The data can be accessed in from of pandas data frame, if it is loaded with function `load_pandas`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "dc616b78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    },
    {
     "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>cancer</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>445.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>559.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   cancer  population\n",
       "0     1.0       445.0\n",
       "1     0.0       559.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "\n",
    "bc_cancer_set = sm.datasets.cancer\n",
    "bc_cancer = bc_cancer_set.load()\n",
    "bc_cancer_data = bc_cancer.data\n",
    "\n",
    "print(type(bc_cancer_data))\n",
    "bc_cancer_data.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c552bb7e",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> Linear Regression with statsmodels </font>\n",
    "* Let's understand how to fit a linear regression model for Icecream dataset available from R Data Repository.\n",
    "* The icecream_data dataset is a pandas data frame. It contains four variables: cons (consumption), income, price, and temp (temperature)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a7b23a79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['cons', 'income', 'price', 'temp'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "icecream = sm.datasets.get_rdataset(\"Icecream\", \"Ecdat\")\n",
    "icecream_data = icecream.data\n",
    "\n",
    "print(icecream_data.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "56581791",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                   cons   R-squared:                       0.633\n",
      "Model:                            OLS   Adj. R-squared:                  0.606\n",
      "Method:                 Least Squares   F-statistic:                     23.27\n",
      "Date:                Tue, 27 Dec 2022   Prob (F-statistic):           1.34e-06\n",
      "Time:                        17:43:49   Log-Likelihood:                 54.607\n",
      "No. Observations:                  30   AIC:                            -103.2\n",
      "Df Residuals:                      27   BIC:                            -99.01\n",
      "Df Model:                           2                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "Intercept      0.5966      0.258      2.309      0.029       0.067       1.127\n",
      "price         -1.4018      0.925     -1.515      0.141      -3.300       0.496\n",
      "temp           0.0030      0.000      6.448      0.000       0.002       0.004\n",
      "==============================================================================\n",
      "Omnibus:                        0.991   Durbin-Watson:                   0.656\n",
      "Prob(Omnibus):                  0.609   Jarque-Bera (JB):                0.220\n",
      "Skew:                          -0.107   Prob(JB):                        0.896\n",
      "Kurtosis:                       3.361   Cond. No.                     6.58e+03\n",
      "==============================================================================\n",
      "\n",
      "Notes:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
      "[2] The condition number is large, 6.58e+03. This might indicate that there are\n",
      "strong multicollinearity or other numerical problems.\n"
     ]
    }
   ],
   "source": [
    "# Initially, let's model consumption with price and temperature, as a linear model.\n",
    "# The patsy formula for assumed model is: cons ~ price + temp\n",
    "\n",
    "# Creating a Model with Ordinary Least Square Regression (ols)\n",
    "linear_model1 = smf.ols('cons ~ price + temp', icecream_data)\n",
    "\n",
    "# Fitting the Model\n",
    "linear_result1 = linear_model1.fit()\n",
    "\n",
    "# Viewing Model Summary\n",
    "print(linear_result1.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f8fe792",
   "metadata": {},
   "source": [
    "* The R-squared value of 0.633 suggests that model is not a proper fit.\n",
    "* The probability value of coefficient price is high, i.e., 0.141. This accepts the null-hypothesis: the value of price coefficient is equal to zero.\n",
    "* Hence, the variable price does not affect cons variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a2004986",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                   cons   R-squared:                       0.702\n",
      "Model:                            OLS   Adj. R-squared:                  0.680\n",
      "Method:                 Least Squares   F-statistic:                     31.81\n",
      "Date:                Tue, 27 Dec 2022   Prob (F-statistic):           7.96e-08\n",
      "Time:                        17:43:49   Log-Likelihood:                 57.742\n",
      "No. Observations:                  30   AIC:                            -109.5\n",
      "Df Residuals:                      27   BIC:                            -105.3\n",
      "Df Model:                           2                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "Intercept     -0.1132      0.108     -1.045      0.305      -0.335       0.109\n",
      "income         0.0035      0.001      3.017      0.006       0.001       0.006\n",
      "temp           0.0035      0.000      7.963      0.000       0.003       0.004\n",
      "==============================================================================\n",
      "Omnibus:                        2.264   Durbin-Watson:                   1.003\n",
      "Prob(Omnibus):                  0.322   Jarque-Bera (JB):                1.094\n",
      "Skew:                           0.386   Prob(JB):                        0.579\n",
      "Kurtosis:                       3.528   Cond. No.                     1.56e+03\n",
      "==============================================================================\n",
      "\n",
      "Notes:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
      "[2] The condition number is large, 1.56e+03. This might indicate that there are\n",
      "strong multicollinearity or other numerical problems.\n"
     ]
    }
   ],
   "source": [
    "# Now let's create a new model by considered income and temp dependent variables.\n",
    "linear_model2 = smf.ols('cons ~ income + temp', icecream_data)\n",
    "linear_result2 = linear_model2.fit()\n",
    "\n",
    "print(linear_result2.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f21d5ed",
   "metadata": {},
   "source": [
    "* R-squared value improved to 0.702, suggesting this is a better model than previous one.\n",
    "* Probability values of income and temp are low, indicating they are highly significant to cons.\n",
    "* The probability value of Intercept is too high."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b556ae76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                 OLS Regression Results                                \n",
      "=======================================================================================\n",
      "Dep. Variable:                   cons   R-squared (uncentered):                   0.990\n",
      "Model:                            OLS   Adj. R-squared (uncentered):              0.990\n",
      "Method:                 Least Squares   F-statistic:                              1426.\n",
      "Date:                Tue, 27 Dec 2022   Prob (F-statistic):                    6.77e-29\n",
      "Time:                        17:43:49   Log-Likelihood:                          57.146\n",
      "No. Observations:                  30   AIC:                                     -110.3\n",
      "Df Residuals:                      28   BIC:                                     -107.5\n",
      "Df Model:                           2                                                  \n",
      "Covariance Type:            nonrobust                                                  \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "income         0.0023      0.000      9.906      0.000       0.002       0.003\n",
      "temp           0.0033      0.000      8.571      0.000       0.003       0.004\n",
      "==============================================================================\n",
      "Omnibus:                        3.584   Durbin-Watson:                   0.887\n",
      "Prob(Omnibus):                  0.167   Jarque-Bera (JB):                2.089\n",
      "Skew:                           0.508   Prob(JB):                        0.352\n",
      "Kurtosis:                       3.798   Cond. No.                         6.45\n",
      "==============================================================================\n",
      "\n",
      "Notes:\n",
      "[1] R² is computed without centering (uncentered) since the model does not contain a constant.\n",
      "[2] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
     ]
    }
   ],
   "source": [
    "# Now let's create a new model without considering intercept term.\n",
    "linear_model3 = smf.ols('cons ~ -1 + income + temp', icecream_data)\n",
    "linear_result3 = linear_model3.fit()\n",
    "\n",
    "print(linear_result3.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a3f1580",
   "metadata": {},
   "source": [
    "* R-squared value increased to 0.990, which suggests the model could best describe the relationship of cons with income and temp variables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cd4fd51",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> Logistic Regression with statsmodels </font>\n",
    "* Logistic regression is a classification algorithm.\n",
    "* `statsmodels` provide the following classes to work with discrete regression problems.\n",
    "    * `Logit`: for Logistic Regression\n",
    "    * `MNLogit`: for Multinomial Logistic Regression\n",
    "    * `Poisson`: for Poisson Regression\n",
    "* Now, let's understand how to perform logistic regression using statsmodels with the following steps:\n",
    "    1. Download the popular iris data set (containing data of 3 species) from R repository.\n",
    "    2. Subset the data of only two species.\n",
    "    3. Perform transformations, if required.\n",
    "    4. Define a patsy formula and create a model using logit.\n",
    "    5. Fit the model with supplied data.\n",
    "    6. View summary of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9466bca4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['setosa', 'versicolor', 'virginica'], dtype=object)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = sm.datasets.get_rdataset(\"iris\").data \n",
    "\n",
    "# df.info()\n",
    "df.Species.unique() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4f31bc84",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['versicolor' 'virginica']\n"
     ]
    }
   ],
   "source": [
    "# Selecting Required Data\n",
    "\n",
    "df_subset = df[(df.Species == \"versicolor\") | (df.Species == \"virginica\")].copy()\n",
    "print(df_subset.Species.unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d31ad0fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A binary variable corresponding to two species is created using map function as shown below.\n",
    "df_subset.Species = df_subset.Species.map({\"versicolor\": 1, \"virginica\": 0}) \n",
    "\n",
    "# period characters, present in column names are replaced with underscore characters.\n",
    "df_subset.rename(columns={\"Sepal.Length\": \"Sepal_Length\", \"Sepal.Width\": \"Sepal_Width\",\t\"Petal.Length\": \"Petal_Length\", \"Petal.Width\": \"Petal_Width\"}, inplace=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4f4f4f9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.102818\n",
      "         Iterations 10\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table class=\"simpletable\">\n",
       "<caption>Logit Regression Results</caption>\n",
       "<tr>\n",
       "  <th>Dep. Variable:</th>        <td>Species</td>     <th>  No. Observations:  </th>  <td>   100</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Model:</th>                 <td>Logit</td>      <th>  Df Residuals:      </th>  <td>    97</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Method:</th>                 <td>MLE</td>       <th>  Df Model:          </th>  <td>     2</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Date:</th>            <td>Tue, 27 Dec 2022</td> <th>  Pseudo R-squ.:     </th>  <td>0.8517</td>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Time:</th>                <td>17:43:52</td>     <th>  Log-Likelihood:    </th> <td> -10.282</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>converged:</th>             <td>True</td>       <th>  LL-Null:           </th> <td> -69.315</td> \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Covariance Type:</th>     <td>nonrobust</td>    <th>  LLR p-value:       </th> <td>2.303e-26</td>\n",
       "</tr>\n",
       "</table>\n",
       "<table class=\"simpletable\">\n",
       "<tr>\n",
       "        <td></td>          <th>coef</th>     <th>std err</th>      <th>z</th>      <th>P>|z|</th>  <th>[0.025</th>    <th>0.975]</th>  \n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Intercept</th>    <td>   45.2723</td> <td>   13.612</td> <td>    3.326</td> <td> 0.001</td> <td>   18.594</td> <td>   71.951</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Petal_Length</th> <td>   -5.7545</td> <td>    2.306</td> <td>   -2.496</td> <td> 0.013</td> <td>  -10.274</td> <td>   -1.235</td>\n",
       "</tr>\n",
       "<tr>\n",
       "  <th>Petal_Width</th>  <td>  -10.4467</td> <td>    3.756</td> <td>   -2.782</td> <td> 0.005</td> <td>  -17.808</td> <td>   -3.086</td>\n",
       "</tr>\n",
       "</table><br/><br/>Possibly complete quasi-separation: A fraction 0.34 of observations can be<br/>perfectly predicted. This might indicate that there is complete<br/>quasi-separation. In this case some parameters will not be identified."
      ],
      "text/plain": [
       "<class 'statsmodels.iolib.summary.Summary'>\n",
       "\"\"\"\n",
       "                           Logit Regression Results                           \n",
       "==============================================================================\n",
       "Dep. Variable:                Species   No. Observations:                  100\n",
       "Model:                          Logit   Df Residuals:                       97\n",
       "Method:                           MLE   Df Model:                            2\n",
       "Date:                Tue, 27 Dec 2022   Pseudo R-squ.:                  0.8517\n",
       "Time:                        17:43:52   Log-Likelihood:                -10.282\n",
       "converged:                       True   LL-Null:                       -69.315\n",
       "Covariance Type:            nonrobust   LLR p-value:                 2.303e-26\n",
       "================================================================================\n",
       "                   coef    std err          z      P>|z|      [0.025      0.975]\n",
       "--------------------------------------------------------------------------------\n",
       "Intercept       45.2723     13.612      3.326      0.001      18.594      71.951\n",
       "Petal_Length    -5.7545      2.306     -2.496      0.013     -10.274      -1.235\n",
       "Petal_Width    -10.4467      3.756     -2.782      0.005     -17.808      -3.086\n",
       "================================================================================\n",
       "\n",
       "Possibly complete quasi-separation: A fraction 0.34 of observations can be\n",
       "perfectly predicted. This might indicate that there is complete\n",
       "quasi-separation. In this case some parameters will not be identified.\n",
       "\"\"\""
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A logistic regression model, explaining relationship of \n",
    "# Species variable with Petal_Length and Petal_width is generated using logit function.\n",
    "model = smf.logit(\"Species ~ Petal_Length + Petal_Width\", data=df_subset)\n",
    "\n",
    "# Model is then fit with supplied data using fit function\n",
    "result = model.fit() \n",
    "result.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "3ed50ba3",
   "metadata": {
    "scrolled": true
   },
   "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>Petal_Length</th>\n",
       "      <th>Petal_Width</th>\n",
       "      <th>P-Species</th>\n",
       "      <th>Species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4.783843</td>\n",
       "      <td>1.478423</td>\n",
       "      <td>0.908788</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.998742</td>\n",
       "      <td>1.246526</td>\n",
       "      <td>0.093664</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.556203</td>\n",
       "      <td>1.391860</td>\n",
       "      <td>0.989155</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5.284247</td>\n",
       "      <td>1.969027</td>\n",
       "      <td>0.003315</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.444185</td>\n",
       "      <td>2.009266</td>\n",
       "      <td>0.000870</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Petal_Length  Petal_Width  P-Species  Species\n",
       "0      4.783843     1.478423   0.908788        1\n",
       "1      5.998742     1.246526   0.093664        0\n",
       "2      4.556203     1.391860   0.989155        1\n",
       "3      5.284247     1.969027   0.003315        0\n",
       "4      5.444185     2.009266   0.000870        0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predicting Response Variable\n",
    "df_new = pd.DataFrame({\"Petal_Length\": np.random.randn(20)*0.5 + 5,\n",
    "                       \"Petal_Width\": np.random.randn(20)*0.5 + 1.7})\n",
    "df_new[\"P-Species\"] = result.predict(df_new)\n",
    "df_new[\"P-Species\"].head(3)\n",
    "\n",
    "df_new[\"Species\"] = (df_new[\"P-Species\"] > 0.5).astype(int)\n",
    "df_new.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "92c8cefd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 3.468160\n",
      "         Iterations 7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6.679101716144942e-13"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Poisson Regression example\n",
    "\n",
    "ins_df = sm.datasets.get_rdataset('Insurance', package='MASS',).data \n",
    "data = {'holders':ins_df['Holders'],'claims':ins_df['Claims']}\n",
    "\n",
    "poisson_model = smf.poisson('claims ~ np.log(holders)', data)\n",
    "poisson_model_result = poisson_model.fit()\n",
    "\n",
    "float(poisson_model_result.resid.sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59535877",
   "metadata": {},
   "source": [
    "### <font color=\"blue\"> ANOVA with statsmodels </font>\n",
    "* *anova_lm* method from `anova` module of `statsmodels` library can be used for performing ANOVA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6cbe874b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the Dataset\n",
    "icecream = sm.datasets.get_rdataset(\"Icecream\", \"Ecdat\")\n",
    "icecream_data = icecream.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "9c6a204f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Building the Model\n",
    "model1 = smf.ols('cons ~ temp', icecream_data).fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "21424c15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            df    sum_sq   mean_sq         F        PR(>F)\n",
      "temp       1.0  0.075514  0.075514  42.27997  4.789215e-07\n",
      "Residual  28.0  0.050009  0.001786       NaN           NaN\n"
     ]
    }
   ],
   "source": [
    "# Now let's frame a null hypothesis: Value of B1, i.e., the coefficient of temp variable is zero.\n",
    "\n",
    "from statsmodels.stats import anova\n",
    "\n",
    "print(anova.anova_lm(model1))\n",
    "\n",
    "# The obtained F-statistic is 42.27 and has a very low probability.\n",
    "# Hence, the null hypothesis can be rejected. i.e., B1 is not equal to zero."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d06465d",
   "metadata": {},
   "source": [
    "#### <font color=\"grey\"> Determining F-Value </font>\n",
    "* F-statistic is defined as Mean square of model / Mean square of residuals.\n",
    "* Mean square of model is sum of squares values of all variables / degrees of freedom"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f69b9b6",
   "metadata": {},
   "source": [
    "## <font color=\"#fe7401\"> MCQ's </font>\n",
    "1. An alternative hypothesis states there is no effect. State true or false. False\n",
    "2. While performing anova on a regression model fitted with multiple variables, the alternative hypothesis is framed as: Coefficients of all independent variables not equal to zero. State if it is true or false? False\n",
    "3. Which of the following function, available in statsmodels, is used to fit a Poisson regression model? poisson\n",
    "4. Which of the following expressions correctly calculate the variance of a sample, x, derived from a population? np.var(x, ddof=1)\n",
    "5. The greater the value of the F ratio ? the less the sample distributions overlap\n",
    "6. The patsy formula `y ~ x1*x2` is equivalent to which of the following expressions? `y ~ x1 + x2 + x1*x2`\n",
    "7. In a linear regression, the coefficients of the model are estimated by minimizing the sum of the squares of ? residuals\n",
    "8. Which of the following definition is used by default in kurtosis method of scipy.stats module? fisher\n",
    "9. Which of the following method of scipy.stats module is used to determine inter quartile range a distribution? iqr\n",
    "10. R-square value close to zero indicates a good fit. State if it is true or false? False\n",
    "11. Which of the following function is used to test goodness of fit of a continuous distribution to data? stats.kstest\n",
    "12. Which of the following function is used to treat a numeric variable as a categorical one? C \n",
    "13. What is the cumulative probability of finding F-statistic lower than 1, for a F distribution with degrees of freedom 2 and 27? 0.619\n",
    "14. Given, slope of a linear regression line is 1.5, and when x is 10 y takes the value of 8. Determine the intercept of the regression line. -7 (y = mx + c)\n",
    "15. What is the cumulative probability of finding F-statistic higher than 1, for a F distribution with degrees of freedom 2 and 27? 0.381\n",
    "16. While performing anova on a regression model fitted with a single variable, the null hypothesis is framed as: Coefficient of independent variable is zero. State if it is true or false? True\n",
    "17. Which of the following method is used to generate random numbers for a defined distribution available in scipy.stats module? rvs\n",
    "18. Whether a student will pass or fail in the competitive exam based on hours of study can be solved using? Logistic Regression\n",
    "19. What is the output of ?\n",
    "```\n",
    "from scipy import stats\n",
    "print(stats.mode([8, 9, 8, 7, 9, 6, 7, 6]))\n",
    "```\n",
    "Ans: ```ModeResult(mode=array([6]), count=array([2]))```"
   ]
  }
 ],
 "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}