From 642ba2b80af208b0169f0ac184a21ef030e77acb Mon Sep 17 00:00:00 2001 From: s444501 Date: Fri, 13 May 2022 22:06:56 +0200 Subject: [PATCH 1/8] misc. changes --- bootstrap-t.ipynb | 59 +++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 49 insertions(+), 10 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index cd93786..af28d86 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -1,8 +1,31 @@ { "cells": [ + { + "cell_type": "markdown", + "source": [ + "Bootstrapowa wersja testu t.\n", + "Implementacja powinna obejmować test dla jednej próby, dla dwóch prób niezależnych oraz dla dwóch prób zależnych.\n", + "W każdej sytuacji oczekiwanym wejście jest zbiór danych w odpowiednim formacie, a wyjściem p-wartość oraz ostateczna decyzja.\n", + "Dodatkowo powinien być rysowany odpowiedni rozkład statystyki testowej." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Zbiór danych - ???\n", + "Hipoteza zerowa - ???\n", + "Hipoteza alternatywna - ???" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 50, "metadata": { "pycharm": { "name": "#%%\n" @@ -19,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 51, "metadata": { "pycharm": { "name": "#%%\n" @@ -29,14 +52,14 @@ "source": [ "def generate_bootstraps(data, n_bootstraps=100):\n", " data_size = data.shape[0]\n", - " for b in range(n_bootstraps):\n", - " indicies = np.random.choice(len(data), size=data_size)\n", - " yield data.iloc[indicies, :]" + " for _ in range(n_bootstraps):\n", + " indices = np.random.choice(len(data), size=data_size)\n", + " yield data.iloc[indices, :]" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 52, "outputs": [], "source": [ "def get_t_stat(data1, data2):\n", @@ -57,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 53, "metadata": { "pycharm": { "name": "#%%\n" @@ -80,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 54, "outputs": [], "source": [ "def make_decision(data, columns, alpha=0.05):\n", @@ -104,13 +127,29 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 55, + "outputs": [], + "source": [ + "def draw_distribution():\n", + " \"\"\"Funkcja rysuje rozkład statystyki testowej\"\"\"\n", + " pass" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 56, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t: 6.903407918031469, df: 998, cv: 1.6463818766348755, p: 9.018563673635072e-12\n", + "t: 6.891235313595221, df: 998, cv: 1.6463818766348755, p: 9.78683800667568e-12\n", "\n", "Reject the null hypothesis that the means are equal.\n", "Reject the null hypothesis that the means are equal.\n" From d445516c2ca023870bd9fd7443c1ee420372643c Mon Sep 17 00:00:00 2001 From: s444501 Date: Fri, 13 May 2022 23:43:00 +0200 Subject: [PATCH 2/8] basic histogram with dummy data --- bootstrap-t.ipynb | 44 ++++++++++++++++++++++++++++++++------------ 1 file changed, 32 insertions(+), 12 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index af28d86..76523f4 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -17,7 +17,10 @@ "source": [ "Zbiór danych - ???\n", "Hipoteza zerowa - ???\n", - "Hipoteza alternatywna - ???" + "Hipoteza alternatywna - ???\n", + "\n", + "Dla każdego z 3 testów inne\n", + "https://www.jmp.com/en_ch/statistics-knowledge-portal/t-test.html" ], "metadata": { "collapsed": false @@ -25,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 52, "metadata": { "pycharm": { "name": "#%%\n" @@ -37,12 +40,13 @@ "import pandas as pd\n", "from math import sqrt\n", "from scipy.stats import sem\n", - "from scipy.stats import t" + "from scipy.stats import t\n", + "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 53, "metadata": { "pycharm": { "name": "#%%\n" @@ -59,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 54, "outputs": [], "source": [ "def get_t_stat(data1, data2):\n", @@ -69,6 +73,7 @@ " sem2 = sem(data2)\n", "\n", " sed = sqrt(sem1**2.0 + sem2**2.0)\n", + " # To jest wzór chyba tylko dla jednego przypadku\n", " return (mean1 - mean2) / sed" ], "metadata": { @@ -80,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 55, "metadata": { "pycharm": { "name": "#%%\n" @@ -103,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 56, "outputs": [], "source": [ "def make_decision(data, columns, alpha=0.05):\n", @@ -127,12 +132,27 @@ }, { "cell_type": "code", - "execution_count": 55, - "outputs": [], + "execution_count": 69, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "def draw_distribution():\n", " \"\"\"Funkcja rysuje rozkład statystyki testowej\"\"\"\n", - " pass" + " dummy = np.random.normal(170, 10, 500)\n", + " plt.hist(dummy)\n", + " plt.show()\n", + " pass\n", + "draw_distribution()" ], "metadata": { "collapsed": false, @@ -143,13 +163,13 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 60, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t: 6.891235313595221, df: 998, cv: 1.6463818766348755, p: 9.78683800667568e-12\n", + "t: 6.893215520199072, df: 998, cv: 1.6463818766348755, p: 9.657386002004387e-12\n", "\n", "Reject the null hypothesis that the means are equal.\n", "Reject the null hypothesis that the means are equal.\n" From 0c0ba5643089179904c3d3aca0ede00311d0c48c Mon Sep 17 00:00:00 2001 From: test Date: Sat, 14 May 2022 15:31:47 +0200 Subject: [PATCH 3/8] test statistic function for one sample --- bootstrap-t.ipynb | 70 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 60 insertions(+), 10 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index 76523f4..c62c3ed 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 15, "metadata": { "pycharm": { "name": "#%%\n" @@ -41,12 +41,13 @@ "from math import sqrt\n", "from scipy.stats import sem\n", "from scipy.stats import t\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "from statistics import mean, stdev" ] }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 16, "metadata": { "pycharm": { "name": "#%%\n" @@ -63,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 17, "outputs": [], "source": [ "def get_t_stat(data1, data2):\n", @@ -85,7 +86,56 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, + "outputs": [], + "source": [ + "def t_stat_single(sample, population_mean):\n", + " \"\"\"Funkcja oblicza wartość statystyki testowej dla jednej próbki\"\"\"\n", + " sample_mean = mean(sample)\n", + " sample_std = stdev(sample)\n", + " sample_size = len(sample)\n", + " return (sample_mean - population_mean) / (sample_std / sqrt(sample_size))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "def t_stat_indept():\n", + " pass" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "def t_stat_dep():\n", + " pass" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": { "pycharm": { "name": "#%%\n" @@ -108,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 19, "outputs": [], "source": [ "def make_decision(data, columns, alpha=0.05):\n", @@ -132,12 +182,12 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 20, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -163,13 +213,13 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 21, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t: 6.893215520199072, df: 998, cv: 1.6463818766348755, p: 9.657386002004387e-12\n", + "t: 6.940510630195086, df: 998, cv: 1.6463818766348755, p: 7.02371494298859e-12\n", "\n", "Reject the null hypothesis that the means are equal.\n", "Reject the null hypothesis that the means are equal.\n" From 7caf329f2de59c677f2b8e6502feb1323cbb0a4f Mon Sep 17 00:00:00 2001 From: test Date: Sat, 14 May 2022 16:40:40 +0200 Subject: [PATCH 4/8] test statistic functions for all 3 tests --- bootstrap-t.ipynb | 98 +++++++++++++++++++++++++++++++++++++---------- 1 file changed, 77 insertions(+), 21 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index c62c3ed..7535ea9 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 120, "metadata": { "pycharm": { "name": "#%%\n" @@ -42,12 +42,13 @@ "from scipy.stats import sem\n", "from scipy.stats import t\n", "import matplotlib.pyplot as plt\n", - "from statistics import mean, stdev" + "from statistics import mean, stdev\n", + "from scipy.stats import ttest_ind, ttest_1samp, ttest_rel" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 121, "metadata": { "pycharm": { "name": "#%%\n" @@ -64,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 122, "outputs": [], "source": [ "def get_t_stat(data1, data2):\n", @@ -74,7 +75,6 @@ " sem2 = sem(data2)\n", "\n", " sed = sqrt(sem1**2.0 + sem2**2.0)\n", - " # To jest wzór chyba tylko dla jednego przypadku\n", " return (mean1 - mean2) / sed" ], "metadata": { @@ -86,15 +86,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 123, "outputs": [], "source": [ "def t_stat_single(sample, population_mean):\n", " \"\"\"Funkcja oblicza wartość statystyki testowej dla jednej próbki\"\"\"\n", - " sample_mean = mean(sample)\n", - " sample_std = stdev(sample)\n", " sample_size = len(sample)\n", - " return (sample_mean - population_mean) / (sample_std / sqrt(sample_size))" + " return (mean(sample) - population_mean) / (stdev(sample) / sqrt(sample_size))" ], "metadata": { "collapsed": false, @@ -105,11 +103,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 124, "outputs": [], "source": [ - "def t_stat_indept():\n", - " pass" + "def t_stat_indept(sample_1, sample_2):\n", + " \"\"\"Funkcja oblicza wartość statystyki testowej dla dwóch próbek niezależnych\"\"\"\n", + " # get_t_stat() jest ok już chyba dla równolicznych sampli o tej samej wariancji\n", + " return" ], "metadata": { "collapsed": false, @@ -120,11 +120,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 125, "outputs": [], "source": [ - "def t_stat_dep():\n", - " pass" + "def t_stat_dep(sample_1, sample_2):\n", + " \"\"\"Funkcja oblicza wartość statystyki testowej dla dwóch próbek zależnych\"\"\"\n", + " differences = [x_1 - x_2 for x_1, x_2 in zip(sample_1, sample_2)]\n", + " sample_size = len(sample_1)\n", + " mu = 0 # The constant = zero if we want to test whether the average of the difference is significantly different.\n", + " return (mean(differences) - mu) / (stdev(differences) / sqrt(sample_size))" ], "metadata": { "collapsed": false, @@ -135,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 126, "metadata": { "pycharm": { "name": "#%%\n" @@ -158,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 127, "outputs": [], "source": [ "def make_decision(data, columns, alpha=0.05):\n", @@ -182,12 +186,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 128, "outputs": [ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -213,13 +217,65 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 129, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t: 6.940510630195086, df: 998, cv: 1.6463818766348755, p: 7.02371494298859e-12\n", + "Statystyka testowa dla jednej próby:\n", + "1.414213562373095 - z naszej funkcji\n", + "1.414213562373095 - z gotowej biblioteki\n", + "\n", + "Statystyka testowa dla dwóch prób niezależnych:\n", + "-3.0 - z naszej funkcji\n", + "-3.0 - z gotowej biblioteki\n", + "\n", + "Statystyka testowa dla dwóch prób zależnych:\n", + "-1.6329931618554525 - z naszej funkcji\n", + "-1.632993161855452 - z gotowej biblioteki\n" + ] + } + ], + "source": [ + "# Testy\n", + "dummy = [1, 2, 3, 4, 5]\n", + "dummy2 = [4, 5, 6, 7, 8]\n", + "dummy3 = [1, 3 , 3, 4, 6]\n", + "t_stat_selfmade = t_stat_single(dummy, 2)\n", + "t_stat_lib, _ = ttest_1samp(dummy, 2)\n", + "print('Statystyka testowa dla jednej próby:')\n", + "print(t_stat_selfmade, '- z naszej funkcji')\n", + "print(t_stat_lib, '- z gotowej biblioteki')\n", + "print()\n", + "t_stat_selfmade = get_t_stat(dummy, dummy2)\n", + "t_stat_lib, _ = ttest_ind(dummy, dummy2)\n", + "print('Statystyka testowa dla dwóch prób niezależnych:')\n", + "print(t_stat_selfmade, '- z naszej funkcji')\n", + "print(t_stat_lib, '- z gotowej biblioteki')\n", + "print()\n", + "t_stat_selfmade = t_stat_dep(dummy, dummy3)\n", + "t_stat_lib, _ = ttest_rel(dummy, dummy3)\n", + "print('Statystyka testowa dla dwóch prób zależnych:')\n", + "print(t_stat_selfmade, '- z naszej funkcji')\n", + "print(t_stat_lib, '- z gotowej biblioteki')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 130, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t: 6.89001510574949, df: 998, cv: 1.6463818766348755, p: 9.867218153658541e-12\n", "\n", "Reject the null hypothesis that the means are equal.\n", "Reject the null hypothesis that the means are equal.\n" From 3c3ed25e63e1a7152a4319359f6b3e00590e1208 Mon Sep 17 00:00:00 2001 From: test Date: Sat, 14 May 2022 16:47:42 +0200 Subject: [PATCH 5/8] delete old function --- bootstrap-t.ipynb | 55 +++++++++++++++-------------------------------- 1 file changed, 17 insertions(+), 38 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index 7535ea9..338ab8f 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": 142, "metadata": { "pycharm": { "name": "#%%\n" @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 121, + "execution_count": 143, "metadata": { "pycharm": { "name": "#%%\n" @@ -65,28 +65,7 @@ }, { "cell_type": "code", - "execution_count": 122, - "outputs": [], - "source": [ - "def get_t_stat(data1, data2):\n", - " mean1 = np.mean(data1)\n", - " mean2 = np.mean(data2)\n", - " sem1 = sem(data1)\n", - " sem2 = sem(data2)\n", - "\n", - " sed = sqrt(sem1**2.0 + sem2**2.0)\n", - " return (mean1 - mean2) / sed" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": 123, + "execution_count": 144, "outputs": [], "source": [ "def t_stat_single(sample, population_mean):\n", @@ -103,13 +82,13 @@ }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 145, "outputs": [], "source": [ - "def t_stat_indept(sample_1, sample_2):\n", + "def t_stat_ind(sample_1, sample_2):\n", " \"\"\"Funkcja oblicza wartość statystyki testowej dla dwóch próbek niezależnych\"\"\"\n", - " # get_t_stat() jest ok już chyba dla równolicznych sampli o tej samej wariancji\n", - " return" + " sed = sqrt(sem(sample_1)**2 + sem(sample_2)**2)\n", + " return (mean(sample_1) - mean(sample_2)) / sed" ], "metadata": { "collapsed": false, @@ -120,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 146, "outputs": [], "source": [ "def t_stat_dep(sample_1, sample_2):\n", @@ -139,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 147, "metadata": { "pycharm": { "name": "#%%\n" @@ -150,7 +129,7 @@ "def independent_t_test(data, columns, alpha=0.05):\n", " t_stat_sum = 0\n", " for sample in generate_bootstraps(data):\n", - " t_stat_sum += get_t_stat(sample[columns[0]], sample[columns[1]])\n", + " t_stat_sum += t_stat_ind(sample[columns[0]], sample[columns[1]])\n", "\n", " data_size = data.shape[0]\n", " t_stat = t_stat_sum / data_size\n", @@ -162,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 148, "outputs": [], "source": [ "def make_decision(data, columns, alpha=0.05):\n", @@ -186,12 +165,12 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 149, "outputs": [ { "data": { "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAP2UlEQVR4nO3df4xlZX3H8fdHVrBqK+COW7pLOpuKbaipilNK48+CqQjGpa0lEFO3SrLRqsUfrS7aiEljsqjVatLabIW6tgShSMu21FbcYkmTsjog8htZEWTXhR3jz9ZERb/9454tt8PM7s49M3tnHt6vZHLPeZ5z5nyfPTOfOfe5595NVSFJasvjxl2AJGnxGe6S1CDDXZIaZLhLUoMMd0lq0KpxFwCwevXqmpycHHcZkrSi3Hjjjd+oqom5+pZFuE9OTjI9PT3uMiRpRUly/3x9TstIUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDlsU7VKXlbHLzNWM57n1bzhzLcdUGr9wlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMOGu5JLkmyL8ltQ23vT3JXkluS/EOSo4f6LkiyK8ndSV66RHVLkg7gUK7cPw6cPqvtWuCZVfUrwJeBCwCSnAicA/xyt89fJjli0aqVJB2Sg4Z7VV0PfHNW22eq6uFu9QZgXbe8AfhkVf2gqr4K7AJOXsR6JUmHYDHm3F8LfLpbXgs8MNS3u2uTJB1GvcI9ybuAh4FLR9h3U5LpJNMzMzN9ypAkzTJyuCf5feDlwKuqqrrmPcDxQ5ut69oepaq2VtVUVU1NTEyMWoYkaQ4jhXuS04G3A6+oqu8PdW0HzklyVJL1wAnA5/uXKUlaiFUH2yDJZcCLgdVJdgMXMrg75ijg2iQAN1TV66rq9iRXAHcwmK55Q1X9eKmKlyTN7aDhXlXnztF88QG2fy/w3j5FSZL68R2qktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXooOGe5JIk+5LcNtR2bJJrk9zTPR7TtSfJR5LsSnJLkpOWsnhJ0twO5cr948Dps9o2Azuq6gRgR7cO8DLghO5rE/DRxSlTkrQQBw33qroe+Oas5g3Atm55G3DWUPsnauAG4Ogkxy1SrZKkQzTqnPuaqtrbLT8IrOmW1wIPDG23u2t7lCSbkkwnmZ6ZmRmxDEnSXHq/oFpVBdQI+22tqqmqmpqYmOhbhiRpyKjh/tD+6ZbucV/Xvgc4fmi7dV2bJOkwGjXctwMbu+WNwNVD7a/u7po5BfjO0PSNJOkwWXWwDZJcBrwYWJ1kN3AhsAW4Isl5wP3A2d3m/wKcAewCvg+8ZglqliQdxEHDvarOnafrtDm2LeANfYuSZpvcfM24S5BWFN+hKkkNMtwlqUGGuyQ1yHCXpAYZ7pLUoIPeLSNpPMZ1h9B9W84cy3G1uLxyl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1qFe4J3lLktuT3JbksiRPSLI+yc4ku5JcnuTIxSpWknRoRg73JGuBPwSmquqZwBHAOcBFwIeq6unAt4DzFqNQSdKh6zstswr4qSSrgCcCe4FTgSu7/m3AWT2PIUlaoJHDvar2AB8AvsYg1L8D3Ah8u6oe7jbbDayda/8km5JMJ5memZkZtQxJ0hz6TMscA2wA1gM/BzwJOP1Q96+qrVU1VVVTExMTo5YhSZpDn2mZlwBfraqZqvoRcBXwPODobpoGYB2wp2eNkqQF6hPuXwNOSfLEJAFOA+4ArgNe2W2zEbi6X4mSpIXqM+e+k8ELpzcBt3bfayvwDuCtSXYBTwUuXoQ6JUkLsOrgm8yvqi4ELpzVfC9wcp/vK0nqx3eoSlKDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktSgXuGe5OgkVya5K8mdSX49ybFJrk1yT/d4zGIVK0k6NH2v3D8M/GtV/RLwLOBOYDOwo6pOAHZ065Kkw2jkcE/yFOCFwMUAVfXDqvo2sAHY1m22DTirX4mSpIXqc+W+HpgB/ibJF5N8LMmTgDVVtbfb5kFgzVw7J9mUZDrJ9MzMTI8yJEmz9Qn3VcBJwEer6jnA/zBrCqaqCqi5dq6qrVU1VVVTExMTPcqQJM3WJ9x3A7urame3fiWDsH8oyXEA3eO+fiVKkhZq5HCvqgeBB5L8Ytd0GnAHsB3Y2LVtBK7uVaEkacFW9dz/TcClSY4E7gVew+APxhVJzgPuB87ueQwtI5Obrxl3CZIOQa9wr6qbgak5uk7r830lSf34DlVJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSg/q+Q1VSY8b5LuT7tpw5tmO3xit3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBvUO9yRHJPlikn/u1tcn2ZlkV5LLkxzZv0xJ0kIsxpX7+cCdQ+sXAR+qqqcD3wLOW4RjSJIWoFe4J1kHnAl8rFsPcCpwZbfJNuCsPseQJC1c3yv3PwfeDvykW38q8O2qerhb3w2snWvHJJuSTCeZnpmZ6VmGJGnYyOGe5OXAvqq6cZT9q2prVU1V1dTExMSoZUiS5tDnv9l7HvCKJGcATwB+BvgwcHSSVd3V+zpgT/8yJUkLMfKVe1VdUFXrqmoSOAf496p6FXAd8Mpus43A1b2rlCQtyFLc5/4O4K1JdjGYg794CY4hSTqAPtMy/6eqPgd8rlu+Fzh5Mb6vJGk0vkNVkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGLcp97jq8JjdfM+4SJC1zXrlLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAaNHO5Jjk9yXZI7ktye5Pyu/dgk1ya5p3s8ZvHKlSQdij5X7g8Db6uqE4FTgDckORHYDOyoqhOAHd26JOkwGjncq2pvVd3ULX8PuBNYC2wAtnWbbQPO6lmjJGmBFmXOPckk8BxgJ7CmqvZ2XQ8Ca+bZZ1OS6STTMzMzi1GGJKnTO9yTPBn4FPDmqvrucF9VFVBz7VdVW6tqqqqmJiYm+pYhSRrSK9yTPJ5BsF9aVVd1zQ8lOa7rPw7Y169ESdJC9blbJsDFwJ1V9cGhru3Axm55I3D16OVJkkaxqse+zwN+D7g1yc1d2zuBLcAVSc4D7gfO7lWhJGnBRg73qvpPIPN0nzbq95Uk9ec7VCWpQYa7JDWoz5y7JC2qyc3XjOW49205cyzHXUpeuUtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDvc+9hXPfkSlpc4/xdXqp77L1yl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktSgFf/xA34EgCQ9mlfuktSgJQv3JKcnuTvJriSbl+o4kqRHW5JwT3IE8BfAy4ATgXOTnLgUx5IkPdpSXbmfDOyqqnur6ofAJ4ENS3QsSdIsS/WC6lrggaH13cCvDW+QZBOwqVv97yR3L1EtB7Ia+MYYjruYWhgDtDEOx7B8rJhx5KJ5uw5lDD8/X8fY7papqq3A1nEdHyDJdFVNjbOGvloYA7QxDsewfLQwjr5jWKppmT3A8UPr67o2SdJhsFTh/gXghCTrkxwJnANsX6JjSZJmWZJpmap6OMkbgX8DjgAuqarbl+JYPY11WmiRtDAGaGMcjmH5aGEcvcaQqlqsQiRJy4TvUJWkBhnuktSgZsM9ySVJ9iW5bY6+tyWpJKu79ST5SPdRCbckOenwVzy3ucaR5D1J9iS5ufs6Y6jvgm4cdyd56Xiq/v/mOxdJ3pTkriS3J3nfUPuyGwPMey4uHzoP9yW5eahv2Y1jnjE8O8kN3Rimk5zctS/L34t5xvCsJP+V5NYk/5TkZ4b6luN5OD7JdUnu6H7+z+/aj01ybZJ7usdjuvaFn4uqavILeCFwEnDbrPbjGbzQez+wums7A/g0EOAUYOe46z/QOID3AH80x7YnAl8CjgLWA18BjlimY/gN4LPAUd3605bzGA70MzXU/2fAu5fzOOY5F58BXtYtnwF8bmh52f1ezDOGLwAv6pZfC/zpMj8PxwEndcs/DXy5q/V9wOaufTNw0ajnotkr96q6HvjmHF0fAt4ODL+SvAH4RA3cAByd5LjDUOZBHWAcc9kAfLKqflBVXwV2MfgoiLGaZwyvB7ZU1Q+6bfZ17ctyDHDgc5EkwNnAZV3TshzHPGMoYP+V7lOAr3fLy/L3Yp4xPAO4vlu+Fvidbnm5noe9VXVTt/w94E4G7+zfAGzrNtsGnNUtL/hcNBvuc0myAdhTVV+a1TXXxyWsPWyFjeaN3dOzS/Y/dWNljeMZwAuS7EzyH0l+tWtfSWMY9gLgoaq6p1tfSeN4M/D+JA8AHwAu6NpX0hhu55HPr/pdHnkT5bIfQ5JJ4DnATmBNVe3tuh4E1nTLCx7HYybckzwReCfw7nHXsgg+CvwC8GxgL4PpgJVmFXAsg6eYfwxc0V39rlTn8shV+0rzeuAtVXU88Bbg4jHXM4rXAn+Q5EYG0xw/HHM9hyTJk4FPAW+uqu8O99VgPmbke9UfM+HOIAzXA19Kch+Dj0S4KcnPssI+LqGqHqqqH1fVT4C/5pGnmStpHLuBq7qnmZ8HfsLgg5JW0hgASLIK+G3g8qHmlTSOjcBV3fLfswJ/nqrqrqr6zap6LoM/sl/pupbtGJI8nkGwX1pV+//9H9o/3dI97p+uXPA4HjPhXlW3VtXTqmqyqiYZhMtJVfUgg49GeHX3ivQpwHeGnhotO7Pm2n4L2H/XwHbgnCRHJVkPnAB8/nDXd4j+kcGLqiR5BnAkg0/AW0lj2O8lwF1VtXuobSWN4+vAi7rlU4H9U0sr5vciydO6x8cBfwL8Vde1LM9D9yz1YuDOqvrgUNd2Bn9s6R6vHmpf2LkY96vGS/hq9GUMpix+xCDIz5vVfx+P3C0TBv+5yFeAW4Gpcdd/oHEAf9vVeUt30o8b2v5d3TjuprsDYtxf84zhSODvGPxhugk4dTmP4UA/U8DHgdfNsf2yG8c85+L5wI0M7irZCTy323ZZ/l7MM4bzGdxx8mVgC92775fxeXg+gymXW4Cbu68zgKcCOxj8gf0scOyo58KPH5CkBj1mpmUk6bHEcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkN+l9FDOaKE4lTmQAAAABJRU5ErkJggg==\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -217,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 150, "outputs": [ { "name": "stdout", @@ -248,7 +227,7 @@ "print(t_stat_selfmade, '- z naszej funkcji')\n", "print(t_stat_lib, '- z gotowej biblioteki')\n", "print()\n", - "t_stat_selfmade = get_t_stat(dummy, dummy2)\n", + "t_stat_selfmade = t_stat_ind(dummy, dummy2)\n", "t_stat_lib, _ = ttest_ind(dummy, dummy2)\n", "print('Statystyka testowa dla dwóch prób niezależnych:')\n", "print(t_stat_selfmade, '- z naszej funkcji')\n", @@ -269,13 +248,13 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 151, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t: 6.89001510574949, df: 998, cv: 1.6463818766348755, p: 9.867218153658541e-12\n", + "t: 6.914346193374633, df: 998, cv: 1.6463818766348755, p: 8.378631122241131e-12\n", "\n", "Reject the null hypothesis that the means are equal.\n", "Reject the null hypothesis that the means are equal.\n" From e2ff7032bfe4a51987e38179c1f054648d25b6a9 Mon Sep 17 00:00:00 2001 From: test Date: Sat, 14 May 2022 17:09:29 +0200 Subject: [PATCH 6/8] declare test functions --- bootstrap-t.ipynb | 47 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index 338ab8f..eb9d804 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -106,7 +106,7 @@ " \"\"\"Funkcja oblicza wartość statystyki testowej dla dwóch próbek zależnych\"\"\"\n", " differences = [x_1 - x_2 for x_1, x_2 in zip(sample_1, sample_2)]\n", " sample_size = len(sample_1)\n", - " mu = 0 # The constant = zero if we want to test whether the average of the difference is significantly different.\n", + " mu = 0 # The constant is zero if we want to test whether the average of the difference is significantly different.\n", " return (mean(differences) - mu) / (stdev(differences) / sqrt(sample_size))" ], "metadata": { @@ -116,6 +116,51 @@ } } }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "def bootstrap_one_sample():\n", + " return" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "def bootstrap_independent():\n", + " return" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "def bootstrap_dependent():\n", + " return" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, { "cell_type": "code", "execution_count": 147, From 0f1d0b16c0fd52c81e01bb93900d3ab499d3e919 Mon Sep 17 00:00:00 2001 From: test Date: Sat, 14 May 2022 18:13:51 +0200 Subject: [PATCH 7/8] comments --- bootstrap-t.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index eb9d804..770549f 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -226,11 +226,11 @@ "source": [ "def draw_distribution():\n", " \"\"\"Funkcja rysuje rozkład statystyki testowej\"\"\"\n", + " # Losowe dane bo nie jestem pewien co tu dać teraz\n", " dummy = np.random.normal(170, 10, 500)\n", " plt.hist(dummy)\n", " plt.show()\n", - " pass\n", - "draw_distribution()" + "draw_distribution() # To trzeba wywalić potem" ], "metadata": { "collapsed": false, From f2a8b2c167f10611dde29794347d51126192a8c6 Mon Sep 17 00:00:00 2001 From: s444501 Date: Mon, 16 May 2022 18:52:49 +0200 Subject: [PATCH 8/8] histogram --- bootstrap-t.ipynb | 86 ++++++++++++++++++++++++++--------------------- 1 file changed, 48 insertions(+), 38 deletions(-) diff --git a/bootstrap-t.ipynb b/bootstrap-t.ipynb index 770549f..8c2b43d 100644 --- a/bootstrap-t.ipynb +++ b/bootstrap-t.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 239, "metadata": { "pycharm": { "name": "#%%\n" @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 240, "metadata": { "pycharm": { "name": "#%%\n" @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": 241, "outputs": [], "source": [ "def t_stat_single(sample, population_mean):\n", @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": 242, "outputs": [], "source": [ "def t_stat_ind(sample_1, sample_2):\n", @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 243, "outputs": [], "source": [ "def t_stat_dep(sample_1, sample_2):\n", @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 244, "outputs": [], "source": [ "def bootstrap_one_sample():\n", @@ -133,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 245, "outputs": [], "source": [ "def bootstrap_independent():\n", @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 246, "outputs": [], "source": [ "def bootstrap_dependent():\n", @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": 247, "metadata": { "pycharm": { "name": "#%%\n" @@ -173,25 +173,28 @@ "source": [ "def independent_t_test(data, columns, alpha=0.05):\n", " t_stat_sum = 0\n", + " t_stat_list = []\n", " for sample in generate_bootstraps(data):\n", - " t_stat_sum += t_stat_ind(sample[columns[0]], sample[columns[1]])\n", - "\n", + " stat = t_stat_ind(sample[columns[0]], sample[columns[1]])\n", + " t_stat_list.append(stat)\n", + " t_stat_sum += stat\n", " data_size = data.shape[0]\n", " t_stat = t_stat_sum / data_size\n", " df = 2 * data_size - 2\n", " cv = t.ppf(1.0 - alpha, df)\n", " p = (1.0 - t.cdf(abs(t_stat), df)) * 2.0\n", - " return t_stat, df, cv, p" + " return t_stat, df, cv, p, t_stat_list" ] }, { "cell_type": "code", - "execution_count": 148, + "execution_count": 248, "outputs": [], "source": [ "def make_decision(data, columns, alpha=0.05):\n", - " t_stat, df, cv, p = independent_t_test(data, columns, alpha)\n", + " t_stat, df, cv, p, stats = independent_t_test(data, columns, alpha)\n", " print(f't: {t_stat}, df: {df}, cv: {cv}, p: {p}\\n')\n", + " draw_distribution(stats)\n", " if abs(t_stat) <= cv:\n", "\t print('Accept null hypothesis that the means are equal.')\n", " else:\n", @@ -210,27 +213,18 @@ }, { "cell_type": "code", - "execution_count": 149, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "execution_count": 249, + "outputs": [], "source": [ - "def draw_distribution():\n", - " \"\"\"Funkcja rysuje rozkład statystyki testowej\"\"\"\n", - " # Losowe dane bo nie jestem pewien co tu dać teraz\n", - " dummy = np.random.normal(170, 10, 500)\n", - " plt.hist(dummy)\n", - " plt.show()\n", - "draw_distribution() # To trzeba wywalić potem" + "def draw_distribution(stats): # To powinno być zdefiniowane przed make decision w sumie\n", + " \"\"\"\n", + " Funkcja rysuje rozkład statystyki testowej\n", + " stats: lista statystyk testowych\n", + " \"\"\"\n", + " plt.hist(stats)\n", + " plt.xlabel('Test statistic value')\n", + " plt.ylabel('Frequency')\n", + " plt.show()" ], "metadata": { "collapsed": false, @@ -241,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": 250, "outputs": [ { "name": "stdout", @@ -293,14 +287,30 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 251, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "t: 6.914346193374633, df: 998, cv: 1.6463818766348755, p: 8.378631122241131e-12\n", - "\n", + "t: 6.929903381575467, df: 998, cv: 1.6463818766348755, p: 7.544853630747639e-12\n", + "\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEJCAYAAACT/UyFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAATd0lEQVR4nO3dfbRldX3f8feHh4jIg1CuZKqQawyJUpUJGWgiMWI0lUh9oBoNbQzLJk6aaI0kaZ3Yrkqy6lq4WiE1bWxwiaBBjYoSBDQi9TmtOCDPg9EmQwqMMEZawCQS4Ns/9h45ztxz59zL3Xffmd/7tdZZs/dvP3053Pu5+/zO3r+dqkKS1I59xi5AkrS6DH5JaozBL0mNMfglqTEGvyQ1xuCXpMYMFvxJjkry6SS3JLk5ya/37WcluSPJdf3rhUPVIEnaVYa6jj/JOmBdVV2b5GDgGuClwCuA+6vqPw9yYEnSovYbasdVtQ3Y1k/fl2QL8MTl7OuII46o+fn5FaxOkvZ+11xzzTeram7n9sGCf1KSeeBHgS8BJwGvS/KLwGbgN6vqnsW2n5+fZ/PmzYPXKUl7kyS3LdQ++Je7SQ4CLgbeUFX3Au8AngKsp/tE8LYp221MsjnJ5u3btw9dpiQ1Y9DgT7I/XehfVFUfAaiqu6rqoap6GHgncOJC21bVeVW1oao2zM3t8klFkrRMQ17VE+BdwJaqOmeifd3EaqcBNw1VgyRpV0P28Z8EvAq4Mcl1fdubgNOTrAcK2Ar8yoA1SJJ2MuRVPV8AssCiK4Y6piRp97xzV5IaY/BLUmMMfklqjMEvSY1ZlTt3paHNb7p8lONuPfvUUY4rPRqe8UtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGuODWKRHYawHwIAPgdHyecYvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYMFvxJjkry6SS3JLk5ya/37YcnuTLJ1/p/DxuqBknSroY8438Q+M2qOhb4ceC1SY4FNgFXVdUxwFX9vCRplQwW/FW1raqu7afvA7YATwReAlzYr3Yh8NKhapAk7WpV+viTzAM/CnwJOLKqtvWLvgEcuRo1SJI6gwd/koOAi4E3VNW9k8uqqoCast3GJJuTbN6+ffvQZUpSMwYN/iT704X+RVX1kb75riTr+uXrgLsX2raqzquqDVW1YW5ubsgyJakpQ17VE+BdwJaqOmdi0aXAGf30GcCfDFWDJGlXQz5z9yTgVcCNSa7r294EnA18MMkvAbcBrxiwBknSTgYL/qr6ApApi5831HElSYvzzl1JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUmP3GLkB7j/lNl49dgqQZeMYvSY0x+CWpMQa/JDVmsOBPcn6Su5PcNNF2VpI7klzXv1441PElSQubKfiTPGMZ+74AOGWB9nOran3/umIZ+5UkPQqznvH/QZKrk/xakkNn2aCqPgd8a/mlSZKGMFPwV9WzgX8BHAVck+R9SX5mmcd8XZIb+q6gw5a5D0nSMs3cx19VXwP+PfBG4DnA25PcmuSfLeF47wCeAqwHtgFvm7Ziko1JNifZvH379iUcQpK0mFn7+J+Z5FxgC/DTwIuq6mn99LmzHqyq7qqqh6rqYeCdwImLrHteVW2oqg1zc3OzHkKStBuznvH/PnAtcFxVvbaqrgWoqjvpPgXMJMm6idnTgJumrStJGsasQzacCvxtVT0EkGQf4ICq+puqeu9CGyR5P3AycESS24E3AycnWQ8UsBX4lUdVvSRpyWYN/k8Bzwfu7+cPBD4JPGvaBlV1+gLN71pSdZKkFTdrV88BVbUj9OmnDxymJEnSkGYN/m8nOX7HTJIfA/52mJIkSUOatavnDcCHktwJBPh+4JVDFSVJGs5MwV9VX07yVOBH+qavVtXfD1eWJGkoS3kQywnAfL/N8UmoqvcMUpUkaTAzBX+S99LdcXsd8FDfXIDBL0l7mFnP+DcAx1ZVDVmMJGl4s17VcxPdF7qSpD3crGf8RwC3JLka+M6Oxqp68SBVSZIGM2vwnzVkEZKk1TPr5ZyfTfIDwDFV9akkBwL7DluaJGkIsw7L/Brgw8Af9k1PBC4ZqCZJ0oBm/XL3tcBJwL3w3YeyPGGooiRJw5k1+L9TVQ/smEmyH911/JKkPcyswf/ZJG8CHts/a/dDwMeGK0uSNJRZg38TsB24ke7hKVewhCdvSZLWjlmv6tnxjNx3DluOJGlos47V85cs0KdfVT+44hVJkga1lLF6djgA+Dng8JUvR5I0tJn6+Kvqryded1TV79E9gF2StIeZtavn+InZfeg+ASxlLH9J0hoxa3i/bWL6QWAr8IoVr0YrYn7T5WOXoFUw1v/nrWf7YX9PN+tVPc8duhBJ0uqYtavnNxZbXlXnrEw5kqShLeWqnhOAS/v5FwFXA18boihJ0nBmDf4nAcdX1X0ASc4CLq+qXxiqMEnSMGYdsuFI4IGJ+Qf6NknSHmbWM/73AFcn+Wg//1LgwkEqkiQNataret6S5OPAs/umV1fVV4YrS5I0lFm7egAOBO6tqv8C3J7kyQPVJEka0KyPXnwz8Ebgt/um/YE/GqooSdJwZj3jPw14MfBtgKq6Ezh4qKIkScOZNfgfqKqiH5o5yeOGK0mSNKRZg/+DSf4QeHyS1wCfwoeySNIeabdX9SQJ8MfAU4F7gR8B/kNVXTlwbZKkAew2+KuqklxRVc8AZg77JOcD/xS4u6qe3rcdTvdHZJ5+hM+qumcZdUuSlmnWrp5rk5ywxH1fAJyyU9sm4KqqOga4qp+XJK2iWYP/HwP/K8n/TnJDkhuT3LDYBlX1OeBbOzW/hEfu+L2Q7g5gSdIqWrSrJ8nRVfVXwAtW6HhHVtW2fvobON6PJK263fXxX0I3KudtSS6uqpet1IH77w5q2vIkG4GNAEcfffRKHVaSmre7rp5MTP/gChzvriTrAPp/7562YlWdV1UbqmrD3NzcChxakgS7D/6aMr1clwJn9NNnAH+yAvuUJC3B7rp6jktyL92Z/2P7afr5qqpDpm2Y5P3AycARSW4H3gycTXcz2C8Bt+ED2yVp1S0a/FW173J3XFWnT1n0vOXuU5L06C1lWGZJ0l7A4Jekxhj8ktSYWZ+5K0kAzG+6fLRjbz371NGOvTfxjF+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1Zr8xDppkK3Af8BDwYFVtGKMOSWrRKMHfe25VfXPE40tSk+zqkaTGjBX8BXwyyTVJNo5UgyQ1aayunp+sqjuSPAG4MsmtVfW5yRX6PwgbAY4++ugxapSkvdIoZ/xVdUf/793AR4ETF1jnvKraUFUb5ubmVrtESdprrXrwJ3lckoN3TAP/BLhpteuQpFaN0dVzJPDRJDuO/76q+sQIdUhSk1Y9+KvqL4DjVvu4kqSOl3NKUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNWa/sQsY2vymy0c79tazTx3t2JI0jWf8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1Zq+/jn9MY95DIO2NWvydGuJ+IM/4JakxBr8kNcbgl6TGGPyS1JhRgj/JKUm+muTrSTaNUYMktWrVgz/JvsB/A34WOBY4Pcmxq12HJLVqjDP+E4GvV9VfVNUDwAeAl4xQhyQ1aYzgfyLwfybmb+/bJEmrYM3ewJVkI7Cxn70/yVfHrGeKI4Bvjl3EMlj36ttTa7fu1bVL3Xnro9rfDyzUOEbw3wEcNTH/pL7te1TVecB5q1XUciTZXFUbxq5jqax79e2ptVv36lqtusfo6vkycEySJyf5PuDngUtHqEOSmrTqZ/xV9WCS1wF/CuwLnF9VN692HZLUqlH6+KvqCuCKMY69wtZ0V9QirHv17am1W/fqWpW6U1WrcRxJ0hrhkA2S1BiDfwZJDkhydZLrk9yc5Hf69ov6oSduSnJ+kv3HrnVni9T+rr7thiQfTnLQ2LVOmlb3xPK3J7l/rPqmWeT9viDJXya5rn+tH7nU77FI3UnyliR/nmRLktePXevOFqn98xPv951JLhm51O+xSN3PS3JtX/cXkvzQih+8qnzt5gUEOKif3h/4EvDjwAv7ZQHeD/zq2LUuofZDJtY5B9g0dq2z1N3PbwDeC9w/dp1LeL8vAF4+dn3LqPvVwHuAffplTxi71qX8rEysczHwi2PXOuN7/ufA0/r2XwMuWOlje8Y/g+rsOLvcv39VVV3RLyvgarp7EtaURWq/F7ozOuCxwJr6smda3f1YT/8J+LejFbeIaXWPWNJMFqn7V4HfraqH+/XuHqnEqXb3nic5BPhp4JLVr266Reou4JC+/VDgzpU+tsE/oyT7JrkOuBu4sqq+NLFsf+BVwCdGKm9R02pP8m7gG8BTgd8fr8KFTan7dcClVbVt1OIWscjPylv6rrVzkzxmvAoXNqXupwCvTLI5yceTHDNqkVMs9vsJvBS4asfJzloype5fBq5Icjtdrpy90sc1+GdUVQ9V1Xq6s/oTkzx9YvEfAJ+rqs+PUtxuTKu9ql4N/ENgC/DK8Spc2AJ1/xTwc6zBP1KTprzfv033B/YE4HDgjeNVuLApdT8G+Lvq7iZ9J3D+iCVOtZvfz9PpumLXnCl1nwm8sKqeBLybrit2RRn8S1RV/xf4NHAKQJI3A3PAb4xY1kx2rr1ve4huhNSXjVTWbk3U/Vzgh4CvJ9kKHJjk6yOWtqjJ97uqtvUf7b9D98t84qjFLWKnn5PbgY/0iz4KPHOksmaywO/nEXTv9Zp+SvtE3T8LHDfxieWPgWet9PEM/hkkmUvy+H76scDPALcm+WXgBcDpO/pA15optX91x5UCfR//i4FbRytyAVPqvqaqvr+q5qtqHvibqlr5Kx4ehUV+Vtb1baHrerhprBoXMq1uun7x5/arPYfui8c1ZZHaAV4OXFZVfzdSeVNNqXsLcGiSH+5X29G2otbs6JxrzDrgwv6LxX2AD1bVZUkeBG4D/mf3+8xHqup3R6xzIbvUTnf28/n+S68A19N9ibeWLPiej1zTLKb9rPyPJHN07/d1wL8ascaFTKv7C8BFSc4E7qfrf15rFvtZ+XkG6CNfIdPe89cAFyd5GLgH+JcrfWDv3JWkxtjVI0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfa0KSfzAxkuI3ktwxMf99M2x/cpKZb3RJMp/kny91vSQbkrx9pdZ/tJJ8Jske92xZjcvg15pQVX9dVev729f/O3DujvmqemCGXZzM0u5wnAd2G/w7r1dVm6tqsaGJl7q+tOoMfq1ZSX4syWeTXJPkTyfufn19klv6Ac8+kGSe7oaoM/tPCM/eaT/Pmfj08JUkB9Pd1PPsvu3M/kz98+nGQb924tPDzuudnOSyJex3cv2Dkrw7yY197S/bqc5TknxoYn5y23ekGyhtl2cTTKx//8T0y5Nc0E/PJbk4yZf710nL/X+ivcRyxnL25WvIF3AW8G+APwPm+rZXAuf303cCj+mnHz+xzW9N2d/HgJP66YPo7lg/me5W/h3rHAgc0E8fA2zup3de77vzM+53cv23Ar83seywnercD/gr4HH9/DuAX+inD+//3Rf4DPDMfv4zwIZ++v6Jfb2cfhx34H3AT/bTRwNbxv5/7Gvcl0M2aK16DPB04Mp+OIx9gR1DMd9AN4zAJcw2xvoXgXOSXEQ3rMbt/T4n7Q/813RPxnoI+OGdV1jmfic9n24IAQCq6p7JhVX1YJJPAC9K8mHgVB557sArkmyk++OwDjiW7n2YxfOBYydqOyTJQfXIWPBqjMGvtSrAzVX1EwssOxX4KeBFwL9L8ozFdlRVZye5nO6JaV9M8oIFVjsTuAs4jq4LdLeDes2436X6AN0zB75F96njviRPBn4LOKGq7um7cA5YqKSJ6cnl+9A9kWrNDVSmcdjHr7XqO8Bckp+A7mE3Sf5Rkn2Ao6rq03Rj2h9K181yH3DwQjtK8pSqurGq3gp8mW5c/J3XPxTYVt0oq6+i+4TBCux30pXAaye2P2yBdT4LHA+8hu6PAHRPY/o28P+SHEk3dO9C7krytP49Om2i/ZPAv5447vop26sRBr/Wqofp+qnfmuR6uhEtn0UXyH+U5EbgK8DbqxvL/GPAaQt9uQu8IclNSW4A/h74OF03yUPpHnR9Jt3DdM7oj/VUuqBlgfWWut9J/xE4rN/meh4Z7vi7qns+wmV04X5Z33Z9/996K11//RenvGeb+m3+jEe6xQBeD2zov1C+hbU3MqhWmaNzSlJjPOOXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNeb/A8xCTZ43e5wtAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Reject the null hypothesis that the means are equal.\n", "Reject the null hypothesis that the means are equal.\n" ]