Code-Example-009.1-Two-Sample-t-test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import scipy.stats as stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 10 entries, 0 to 9\n",
      "Data columns (total 2 columns):\n",
      " #   Column    Non-Null Count  Dtype\n",
      "---  ------    --------------  -----\n",
      " 0   strength  10 non-null     int64\n",
      " 1   weeks     10 non-null     int64\n",
      "dtypes: int64(2)\n",
      "memory usage: 288.0 bytes\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(\"./datasets/decay.csv\")\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>strength</th>\n",
       "      <th>weeks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>118</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>126</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>126</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>120</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>129</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>124</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>98</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>110</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>140</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>110</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   strength  weeks\n",
       "0       118      2\n",
       "1       126      2\n",
       "2       126      2\n",
       "3       120      2\n",
       "4       129      2\n",
       "5       124     16\n",
       "6        98     16\n",
       "7       110     16\n",
       "8       140     16\n",
       "9       110     16"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     2\n",
       "1     2\n",
       "2     2\n",
       "3     2\n",
       "4     2\n",
       "5    16\n",
       "6    16\n",
       "7    16\n",
       "8    16\n",
       "9    16\n",
       "Name: weeks, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"weeks\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   strength  weeks\n",
      "0       118      2\n",
      "1       126      2\n",
      "2       126      2\n",
      "3       120      2\n",
      "4       129      2\n",
      "   strength  weeks\n",
      "5       124     16\n",
      "6        98     16\n",
      "7       110     16\n",
      "8       140     16\n",
      "9       110     16\n",
      "0    118\n",
      "1    126\n",
      "2    126\n",
      "3    120\n",
      "4    129\n",
      "Name: strength, dtype: int64 5    124\n",
      "6     98\n",
      "7    110\n",
      "8    140\n",
      "9    110\n",
      "Name: strength, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "two_weeks = df[df[\"weeks\"]==2]\n",
    "print(two_weeks)\n",
    "\n",
    "a = two_weeks[\"strength\"]\n",
    "\n",
    "sixteen_weeks = df[df[\"weeks\"]==16]\n",
    "print(sixteen_weeks)\n",
    "\n",
    "b = sixteen_weeks[\"strength\"]\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function ttest_ind in module scipy.stats.stats:\n",
      "\n",
      "ttest_ind(a, b, axis=0, equal_var=True, nan_policy='propagate', permutations=None, random_state=None, alternative='two-sided', trim=0)\n",
      "    Calculate the T-test for the means of *two independent* samples of scores.\n",
      "    \n",
      "    This is a two-sided test for the null hypothesis that 2 independent samples\n",
      "    have identical average (expected) values. This test assumes that the\n",
      "    populations have identical variances by default.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    a, b : array_like\n",
      "        The arrays must have the same shape, except in the dimension\n",
      "        corresponding to `axis` (the first, by default).\n",
      "    axis : int or None, optional\n",
      "        Axis along which to compute test. If None, compute over the whole\n",
      "        arrays, `a`, and `b`.\n",
      "    equal_var : bool, optional\n",
      "        If True (default), perform a standard independent 2 sample test\n",
      "        that assumes equal population variances [1]_.\n",
      "        If False, perform Welch's t-test, which does not assume equal\n",
      "        population variance [2]_.\n",
      "    \n",
      "        .. versionadded:: 0.11.0\n",
      "    \n",
      "    nan_policy : {'propagate', 'raise', 'omit'}, optional\n",
      "        Defines how to handle when input contains nan.\n",
      "        The following options are available (default is 'propagate'):\n",
      "    \n",
      "          * 'propagate': returns nan\n",
      "          * 'raise': throws an error\n",
      "          * 'omit': performs the calculations ignoring nan values\n",
      "    \n",
      "        The 'omit' option is not currently available for permutation tests or\n",
      "        one-sided asympyotic tests.\n",
      "    \n",
      "    permutations : non-negative int, np.inf, or None (default), optional\n",
      "        If 0 or None (default), use the t-distribution to calculate p-values.\n",
      "        Otherwise, `permutations` is  the number of random permutations that\n",
      "        will be used to estimate p-values using a permutation test. If\n",
      "        `permutations` equals or exceeds the number of distinct partitions of\n",
      "        the pooled data, an exact test is performed instead (i.e. each\n",
      "        distinct partition is used exactly once). See Notes for details.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    \n",
      "    random_state : {None, int, `numpy.random.Generator`,\n",
      "            `numpy.random.RandomState`}, optional\n",
      "    \n",
      "        If `seed` is None (or `np.random`), the `numpy.random.RandomState`\n",
      "        singleton is used.\n",
      "        If `seed` is an int, a new ``RandomState`` instance is used,\n",
      "        seeded with `seed`.\n",
      "        If `seed` is already a ``Generator`` or ``RandomState`` instance then\n",
      "        that instance is used.\n",
      "    \n",
      "        Pseudorandom number generator state used to generate permutations\n",
      "        (used only when `permutations` is not None).\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    \n",
      "    alternative : {'two-sided', 'less', 'greater'}, optional\n",
      "        Defines the alternative hypothesis.\n",
      "        The following options are available (default is 'two-sided'):\n",
      "    \n",
      "          * 'two-sided'\n",
      "          * 'less': one-sided\n",
      "          * 'greater': one-sided\n",
      "    \n",
      "        .. versionadded:: 1.6.0\n",
      "    \n",
      "    trim : float, optional\n",
      "        If nonzero, performs a trimmed (Yuen's) t-test.\n",
      "        Defines the fraction of elements to be trimmed from each end of the\n",
      "        input samples. If 0 (default), no elements will be trimmed from either\n",
      "        side. The number of trimmed elements from each tail is the floor of the\n",
      "        trim times the number of elements. Valid range is [0, .5).\n",
      "    \n",
      "        .. versionadded:: 1.7\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    statistic : float or array\n",
      "        The calculated t-statistic.\n",
      "    pvalue : float or array\n",
      "        The two-tailed p-value.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Suppose we observe two independent samples, e.g. flower petal lengths, and\n",
      "    we are considering whether the two samples were drawn from the same\n",
      "    population (e.g. the same species of flower or two species with similar\n",
      "    petal characteristics) or two different populations.\n",
      "    \n",
      "    The t-test quantifies the difference between the arithmetic means\n",
      "    of the two samples. The p-value quantifies the probability of observing\n",
      "    as or more extreme values assuming the null hypothesis, that the\n",
      "    samples are drawn from populations with the same population means, is true.\n",
      "    A p-value larger than a chosen threshold (e.g. 5% or 1%) indicates that\n",
      "    our observation is not so unlikely to have occurred by chance. Therefore,\n",
      "    we do not reject the null hypothesis of equal population means.\n",
      "    If the p-value is smaller than our threshold, then we have evidence\n",
      "    against the null hypothesis of equal population means.\n",
      "    \n",
      "    By default, the p-value is determined by comparing the t-statistic of the\n",
      "    observed data against a theoretical t-distribution.\n",
      "    When ``1 < permutations < binom(n, k)``, where\n",
      "    \n",
      "    * ``k`` is the number of observations in `a`,\n",
      "    * ``n`` is the total number of observations in `a` and `b`, and\n",
      "    * ``binom(n, k)`` is the binomial coefficient (``n`` choose ``k``),\n",
      "    \n",
      "    the data are pooled (concatenated), randomly assigned to either group `a`\n",
      "    or `b`, and the t-statistic is calculated. This process is performed\n",
      "    repeatedly (`permutation` times), generating a distribution of the\n",
      "    t-statistic under the null hypothesis, and the t-statistic of the observed\n",
      "    data is compared to this distribution to determine the p-value. When\n",
      "    ``permutations >= binom(n, k)``, an exact test is performed: the data are\n",
      "    partitioned between the groups in each distinct way exactly once.\n",
      "    \n",
      "    The permutation test can be computationally expensive and not necessarily\n",
      "    more accurate than the analytical test, but it does not make strong\n",
      "    assumptions about the shape of the underlying distribution.\n",
      "    \n",
      "    Use of trimming is commonly referred to as the trimmed t-test. At times\n",
      "    called Yuen's t-test, this is an extension of Welch's t-test, with the\n",
      "    difference being the use of winsorized means in calculation of the variance\n",
      "    and the trimmed sample size in calculation of the statistic. Trimming is\n",
      "    reccomended if the underlying distribution is long-tailed or contaminated\n",
      "    with outliers [4]_.\n",
      "    \n",
      "    References\n",
      "    ----------\n",
      "    .. [1] https://en.wikipedia.org/wiki/T-test#Independent_two-sample_t-test\n",
      "    \n",
      "    .. [2] https://en.wikipedia.org/wiki/Welch%27s_t-test\n",
      "    \n",
      "    .. [3] http://en.wikipedia.org/wiki/Resampling_%28statistics%29\n",
      "    \n",
      "    .. [4] Yuen, Karen K. \"The Two-Sample Trimmed t for Unequal Population\n",
      "           Variances.\" Biometrika, vol. 61, no. 1, 1974, pp. 165-170. JSTOR,\n",
      "           www.jstor.org/stable/2334299. Accessed 30 Mar. 2021.\n",
      "    \n",
      "    .. [5] Yuen, Karen K., and W. J. Dixon. \"The Approximate Behaviour and\n",
      "           Performance of the Two-Sample Trimmed t.\" Biometrika, vol. 60,\n",
      "           no. 2, 1973, pp. 369-374. JSTOR, www.jstor.org/stable/2334550.\n",
      "           Accessed 30 Mar. 2021.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> from scipy import stats\n",
      "    >>> rng = np.random.default_rng()\n",
      "    \n",
      "    Test with sample with identical means:\n",
      "    \n",
      "    >>> rvs1 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng)\n",
      "    >>> rvs2 = stats.norm.rvs(loc=5, scale=10, size=500, random_state=rng)\n",
      "    >>> stats.ttest_ind(rvs1, rvs2)\n",
      "    Ttest_indResult(statistic=-0.4390847099199348, pvalue=0.6606952038870015)\n",
      "    >>> stats.ttest_ind(rvs1, rvs2, equal_var=False)\n",
      "    Ttest_indResult(statistic=-0.4390847099199348, pvalue=0.6606952553131064)\n",
      "    \n",
      "    `ttest_ind` underestimates p for unequal variances:\n",
      "    \n",
      "    >>> rvs3 = stats.norm.rvs(loc=5, scale=20, size=500, random_state=rng)\n",
      "    >>> stats.ttest_ind(rvs1, rvs3)\n",
      "    Ttest_indResult(statistic=-1.6370984482905417, pvalue=0.1019251574705033)\n",
      "    >>> stats.ttest_ind(rvs1, rvs3, equal_var=False)\n",
      "    Ttest_indResult(statistic=-1.637098448290542, pvalue=0.10202110497954867)\n",
      "    \n",
      "    When ``n1 != n2``, the equal variance t-statistic is no longer equal to the\n",
      "    unequal variance t-statistic:\n",
      "    \n",
      "    >>> rvs4 = stats.norm.rvs(loc=5, scale=20, size=100, random_state=rng)\n",
      "    >>> stats.ttest_ind(rvs1, rvs4)\n",
      "    Ttest_indResult(statistic=-1.9481646859513422, pvalue=0.05186270935842703)\n",
      "    >>> stats.ttest_ind(rvs1, rvs4, equal_var=False)\n",
      "    Ttest_indResult(statistic=-1.3146566100751664, pvalue=0.1913495266513811)\n",
      "    \n",
      "    T-test with different means, variance, and n:\n",
      "    \n",
      "    >>> rvs5 = stats.norm.rvs(loc=8, scale=20, size=100, random_state=rng)\n",
      "    >>> stats.ttest_ind(rvs1, rvs5)\n",
      "    Ttest_indResult(statistic=-2.8415950600298774, pvalue=0.0046418707568707885)\n",
      "    >>> stats.ttest_ind(rvs1, rvs5, equal_var=False)\n",
      "    Ttest_indResult(statistic=-1.8686598649188084, pvalue=0.06434714193919686)\n",
      "    \n",
      "    When performing a permutation test, more permutations typically yields\n",
      "    more accurate results. Use a ``np.random.Generator`` to ensure\n",
      "    reproducibility:\n",
      "    \n",
      "    >>> stats.ttest_ind(rvs1, rvs5, permutations=10000,\n",
      "    ...                 random_state=rng)\n",
      "    Ttest_indResult(statistic=-2.8415950600298774, pvalue=0.0052)\n",
      "    \n",
      "    Take these two samples, one of which has an extreme tail.\n",
      "    \n",
      "    >>> a = (56, 128.6, 12, 123.8, 64.34, 78, 763.3)\n",
      "    >>> b = (1.1, 2.9, 4.2)\n",
      "    \n",
      "    Use the `trim` keyword to perform a trimmed (Yuen) t-test. For example,\n",
      "    using 20% trimming, ``trim=.2``, the test will reduce the impact of one\n",
      "    (``np.floor(trim*len(a))``) element from each tail of sample `a`. It will\n",
      "    have no effect on sample `b` because ``np.floor(trim*len(b))`` is 0.\n",
      "    \n",
      "    >>> stats.ttest_ind(a, b, trim=.2)\n",
      "    Ttest_indResult(statistic=3.4463884028073513,\n",
      "                    pvalue=0.01369338726499547)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "\n",
    "help(ttest_ind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=0.9888665950759691, pvalue=0.17584491853993517)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ttest_ind(a, b,  alternative=\"greater\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=0.9888665950759691, pvalue=0.35168983707987034)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# two-sided test\n",
    "ttest_ind(a, b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from scipy.stats import ttest_rel\n",
    "# ttest_rel(a, b,  alternative=\"greater\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}