t_test_one_sample.ipynb

{"cells":[{"cell_type":"markdown","metadata":{},"source":["## **One-sample t-test**\n","\n","The one-sample t-test is used to check whether a group of data comes from a normal distribution with a specific expected value.\n"]},{"cell_type":"markdown","metadata":{},"source":["### <ins>Defining the conditions<ins>\n","\n","First, we import the module and create the dataset. The dataset needs to be in a pandas dataframe, thus pandas needs to be imported as well:"]},{"cell_type":"code","execution_count":1,"metadata":{},"outputs":[],"source":["import colibripy.stats.parametric.t_test as tt\n","import pandas as pd\n","\n","dataset = [1.4, -0.3, 2.2, 2.7, 2.7, 0.1, 1.1, 3.2, 1.9, 1.3, -0.2, -0.1, 1.0, 1.5, 0.7, 2.1, 2.9, 0.5, 1.0, 2.1]\n","sample_1 = pd.DataFrame(dataset)"]},{"cell_type":"markdown","metadata":{},"source":["Now we can initiate the evaluation by defining the conditions of the t-test. It is a one-sample t-test, thus we need the `OneSample` module. Here, we perform a **'two-sided'** test at **0.05** significance level, and it is tested whether the expected value of the dataset equals to **1**: "]},{"cell_type":"code","execution_count":2,"metadata":{},"outputs":[],"source":["conditions = tt.OneSample(\n","    sample_1=sample_1, alpha=0.05, type=\"two-sided\", reference=1\n",")"]},{"cell_type":"markdown","metadata":{},"source":["The `alpha` only affects the calculated confidence limits, and of course the decision about the nullhypothesis when we compare it to the p-value."]},{"cell_type":"markdown","metadata":{},"source":["### <ins>Changing the conditions<ins>\n","\n","We may want to change the conditions, for example to see 90% confidence interval instead of the 95%, or do a one-sided test instead of a two-sided. We can do that without redefining every conditions:"]},{"cell_type":"code","execution_count":3,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["0.05 and two-sided\n","0.1 and one-sided\n"]}],"source":["print(conditions.alpha, \"and\", conditions.type)\n","conditions.alpha = 0.1\n","conditions.type = \"one-sided\"\n","print(conditions.alpha, \"and\", conditions.type)"]},{"cell_type":"markdown","metadata":{},"source":["### <ins>Performing the test<ins>\n","\n","#### *Two-sided test*\n","\n","Let's perform a **'two-sided'** test at **0.05** significance level, and it is tested whether the expected value of the dataset equals to **1**"]},{"cell_type":"code","execution_count":4,"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>mean</th>\n","      <th>ste</th>\n","      <th>test_statistic</th>\n","      <th>95.0% lower CL</th>\n","      <th>95.0% upper CL</th>\n","      <th>p-value</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>1.39</td>\n","      <td>0.239835</td>\n","      <td>1.626115</td>\n","      <td>0.888019</td>\n","      <td>1.891981</td>\n","      <td>0.120397</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   mean       ste  test_statistic  95.0% lower CL  95.0% upper CL   p-value\n","0  1.39  0.239835        1.626115        0.888019        1.891981  0.120397"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["conditions = tt.OneSample(\n","    sample_1=sample_1, alpha=0.05, type=\"two-sided\", reference=1\n",")\n","results = conditions.test()\n","results"]},{"cell_type":"markdown","metadata":{},"source":["The `.test()` gives the results of the evaluation in a form of a pandas dataframe. The 'mean' is the mean of `sample_1`, 'ste' is the standard error of the difference between the sample mean and the reference, 'test_statistic' is the calculated test statistic, and the lower and upper confidence limits (CL) gives the interval within which the expected value of the population behind the sample can be found with 1-`alpha` probability (95% in this case).\n","\n","The p-value is greater than the significance level, thus the nullhypothesis cannot be rejected; the sample can come from a normal distribution with expected value of 1. \n","\n","The values in the table can be called using the column names, for example:"]},{"cell_type":"code","execution_count":5,"metadata":{},"outputs":[{"data":{"text/plain":["0    0.120397\n","Name: p-value, dtype: float64"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["results[\"p-value\"]"]},{"cell_type":"markdown","metadata":{},"source":["or"]},{"cell_type":"code","execution_count":6,"metadata":{},"outputs":[{"data":{"text/plain":["0.12039689250823349"]},"execution_count":6,"metadata":{},"output_type":"execute_result"}],"source":["results[\"p-value\"].item()"]},{"cell_type":"markdown","metadata":{},"source":["#### *One-sided test*\n","\n","Let's perform a **'one-sided'** test at **0.1** significance level, and it is tested whether the expected value of the dataset is **greater** or equal to **1**. The greater or equal part is defined in the `.test()`:"]},{"cell_type":"code","execution_count":7,"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>mean</th>\n","      <th>ste</th>\n","      <th>test_statistic</th>\n","      <th>90.0% upper CL</th>\n","      <th>p-value</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>1.39</td>\n","      <td>0.239835</td>\n","      <td>1.626115</td>\n","      <td>1.708436</td>\n","      <td>0.939802</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   mean       ste  test_statistic  90.0% upper CL   p-value\n","0  1.39  0.239835        1.626115        1.708436  0.939802"]},"execution_count":7,"metadata":{},"output_type":"execute_result"}],"source":["conditions = tt.OneSample(\n","    sample_1=sample_1, alpha=0.1, type=\"one-sided\", reference=1\n",")\n","results = conditions.test(\">\")\n","results"]},{"cell_type":"markdown","metadata":{},"source":["`.test(\">\")` gives the results of the evaluation in a form of a pandas dataframe. The 'mean' is the mean of `sample_1`, 'ste' is the standard error of the difference between the sample mean and the reference, 'test_statistic' is the calculated test statistic, and the upper confidence limit (CL) gives the biggest value that if assigned to `reference`, the nullhypothesis is on the verge of acceptance. \n","\n","The p-value is greater than the significance level, thus the nullhypothesis cannot be rejected; the sample can come from a normal distribution with expected value of greater than or equal to 1. \n","\n","The values in the table can be called using the column names, for example:"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[{"data":{"text/plain":["0    0.939802\n","Name: p-value, dtype: float64"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["results[\"p-value\"]"]},{"cell_type":"markdown","metadata":{},"source":["or"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[{"data":{"text/plain":["0.9398015537458833"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["results[\"p-value\"].item()"]},{"cell_type":"markdown","metadata":{},"source":["Let's use the upper CL as the `reference` value and perform the test:"]},{"cell_type":"code","execution_count":10,"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>mean</th>\n","      <th>ste</th>\n","      <th>test_statistic</th>\n","      <th>90.0% upper CL</th>\n","      <th>p-value</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>1.39</td>\n","      <td>0.239835</td>\n","      <td>-1.327728</td>\n","      <td>1.708436</td>\n","      <td>0.1</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   mean       ste  test_statistic  90.0% upper CL  p-value\n","0  1.39  0.239835       -1.327728        1.708436      0.1"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["conditions.reference = results[\"90.0% upper CL\"].item()\n","conditions.test(\">\")"]},{"cell_type":"markdown","metadata":{},"source":["As expected, based on the p-value, we are at the verge of accepting the nullhypothesis that the expected value of the sample is greater than or equal to 1.708 at 0.1 significance level.\n"]},{"cell_type":"markdown","metadata":{},"source":["<br/>\n","Let's test if the expected value of the sample is smaller than or equal than 1:"]},{"cell_type":"code","execution_count":11,"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>mean</th>\n","      <th>ste</th>\n","      <th>test_statistic</th>\n","      <th>90.0% lower CL</th>\n","      <th>p-value</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>1.39</td>\n","      <td>0.239835</td>\n","      <td>1.626115</td>\n","      <td>1.071564</td>\n","      <td>0.060198</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   mean       ste  test_statistic  90.0% lower CL   p-value\n","0  1.39  0.239835        1.626115        1.071564  0.060198"]},"execution_count":11,"metadata":{},"output_type":"execute_result"}],"source":["conditions = tt.OneSample(\n","    sample_1=sample_1, alpha=0.1, type=\"one-sided\", reference=1\n",")\n","results = conditions.test(\"<\")\n","results"]},{"cell_type":"markdown","metadata":{},"source":["We reject the nullhypothesis at 0.1 significance level, that is, the expected value of the sample is greater than 1. "]},{"cell_type":"markdown","metadata":{},"source":["Let's use the lower CL as the reference value:"]},{"cell_type":"code","execution_count":12,"metadata":{},"outputs":[{"data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>mean</th>\n","      <th>ste</th>\n","      <th>test_statistic</th>\n","      <th>90.0% lower CL</th>\n","      <th>p-value</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>1.39</td>\n","      <td>0.239835</td>\n","      <td>1.327728</td>\n","      <td>1.071564</td>\n","      <td>0.1</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   mean       ste  test_statistic  90.0% lower CL  p-value\n","0  1.39  0.239835        1.327728        1.071564      0.1"]},"execution_count":12,"metadata":{},"output_type":"execute_result"}],"source":["conditions.reference = results[\"90.0% lower CL\"].item()\n","conditions.test(\"<\")"]},{"cell_type":"markdown","metadata":{},"source":["As expected, based on the p-value, we are at the verge of accepting the nullhypothesis that the expected value of the sample is smaller than or equal to 1.072 at 0.1 significance level."]},{"cell_type":"markdown","metadata":{},"source":["### <ins>Plotting the data<ins>\n","\n","The boxplot of the data with a red horizontal line refering to the value of the reference can be plotted as follows:"]},{"cell_type":"code","execution_count":13,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["conditions.plot()"]},{"cell_type":"markdown","metadata":{},"source":["### <ins>Residual analysis<ins>\n","\n","The residuals can only be called, if `.test()` was called already. The residuals, that is the differences between the values and the sample mean can be obtained as:"]},{"cell_type":"code","execution_count":14,"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>residuals</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>0.01</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>-1.69</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>0.81</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>1.31</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>1.31</td>\n","    </tr>\n","    <tr>\n","      <th>5</th>\n","      <td>-1.29</td>\n","    </tr>\n","    <tr>\n","      <th>6</th>\n","      <td>-0.29</td>\n","    </tr>\n","    <tr>\n","      <th>7</th>\n","      <td>1.81</td>\n","    </tr>\n","    <tr>\n","      <th>8</th>\n","      <td>0.51</td>\n","    </tr>\n","    <tr>\n","      <th>9</th>\n","      <td>-0.09</td>\n","    </tr>\n","    <tr>\n","      <th>10</th>\n","      <td>-1.59</td>\n","    </tr>\n","    <tr>\n","      <th>11</th>\n","      <td>-1.49</td>\n","    </tr>\n","    <tr>\n","      <th>12</th>\n","      <td>-0.39</td>\n","    </tr>\n","    <tr>\n","      <th>13</th>\n","      <td>0.11</td>\n","    </tr>\n","    <tr>\n","      <th>14</th>\n","      <td>-0.69</td>\n","    </tr>\n","    <tr>\n","      <th>15</th>\n","      <td>0.71</td>\n","    </tr>\n","    <tr>\n","      <th>16</th>\n","      <td>1.51</td>\n","    </tr>\n","    <tr>\n","      <th>17</th>\n","      <td>-0.89</td>\n","    </tr>\n","    <tr>\n","      <th>18</th>\n","      <td>-0.39</td>\n","    </tr>\n","    <tr>\n","      <th>19</th>\n","      <td>0.71</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["    residuals\n","0        0.01\n","1       -1.69\n","2        0.81\n","3        1.31\n","4        1.31\n","5       -1.29\n","6       -0.29\n","7        1.81\n","8        0.51\n","9       -0.09\n","10      -1.59\n","11      -1.49\n","12      -0.39\n","13       0.11\n","14      -0.69\n","15       0.71\n","16       1.51\n","17      -0.89\n","18      -0.39\n","19       0.71"]},"execution_count":14,"metadata":{},"output_type":"execute_result"}],"source":["conditions.residuals"]},{"cell_type":"markdown","metadata":{},"source":["The assumption of the residuals following a normal distribution can be checked by residual plots (QQ plot at the left and histogram of the residuals at right):"]},{"cell_type":"code","execution_count":15,"metadata":{},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 2 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["conditions.residual_plot()"]},{"cell_type":"markdown","metadata":{},"source":["Normality test can also be conducted. The following method uses the Shapiro Wilk test:"]},{"cell_type":"code","execution_count":16,"metadata":{},"outputs":[{"data":{"text/plain":["{'p-value': 0.5326040467449369}"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["conditions.normality()"]},{"cell_type":"markdown","metadata":{},"source":["or"]},{"cell_type":"code","execution_count":17,"metadata":{},"outputs":[{"data":{"text/plain":["0.5326040467449369"]},"execution_count":17,"metadata":{},"output_type":"execute_result"}],"source":["conditions.normality()[\"p-value\"]"]},{"cell_type":"markdown","metadata":{},"source":["The normality test is automatically performed when `.test()` is called. If the p-value is lower than 0.05, that is we would reject the nullhypothesis of normality at 0.05 significance level, a warning message is generated automatically. For example:"]},{"cell_type":"code","execution_count":18,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["╒═══════════════════════════════════════════════════════════════════════════════════════════╕\n","│                                         Warning:                                          │\n","╞═══════════════════════════════════════════════════════════════════════════════════════════╡\n","│ The p-value of the Shapiro-Wilk normality test of the residuals is 7.771561172376096e-16. │\n","│     Normality of the residuals is not fulfilled, nonparametric test may be preferred.     │\n","╘═══════════════════════════════════════════════════════════════════════════════════════════╛\n","\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>mean</th>\n","      <th>ste</th>\n","      <th>test_statistic</th>\n","      <th>95.0% lower CL</th>\n","      <th>95.0% upper CL</th>\n","      <th>p-value</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>4.0</td>\n","      <td>3.0</td>\n","      <td>1.0</td>\n","      <td>-8.907958</td>\n","      <td>16.907958</td>\n","      <td>0.42265</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   mean  ste  test_statistic  95.0% lower CL  95.0% upper CL  p-value\n","0   4.0  3.0             1.0       -8.907958       16.907958  0.42265"]},"execution_count":18,"metadata":{},"output_type":"execute_result"}],"source":["sample_1_nonnormal = pd.DataFrame([1, 1, 10])\n","conditions_nonnormal = tt.OneSample(\n","    sample_1=sample_1_nonnormal, alpha=0.05, type=\"two-sided\", reference=1\n",")\n","conditions_nonnormal.test()"]}],"metadata":{"kernelspec":{"display_name":".venv","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.12.4"}},"nbformat":4,"nbformat_minor":2}