diff --git a/lab-hypothesis-testing.ipynb b/lab-hypothesis-testing.ipynb index 0cc26d5..0676953 100644 --- a/lab-hypothesis-testing.ipynb +++ b/lab-hypothesis-testing.ipynb @@ -38,20 +38,23 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "#libraries\n", "import pandas as pd\n", + "from scipy import stats\n", "import scipy.stats as st\n", + "from statsmodels.multivariate.manova import MANOVA\n", "import numpy as np\n", - "\n" + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -278,7 +281,7 @@ "[800 rows x 11 columns]" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -297,11 +300,156 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "#code here" + "# Set the hypothesis\n", + "\n", + "# H0: mean(HP) Type: Dragon > mean(HP) Type: Grass\n", + "# H1: mean(HP) Type: Dragon =< mean(HP) Type: Grass\n", + "# Test: two-sample T-test\n", + "\n", + "# significance level = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Type 1\n", + " Water 112\n", + " Normal 98\n", + " Grass 70\n", + " Bug 69\n", + " Psychic 57\n", + " Fire 52\n", + " Electric 44\n", + " Rock 44\n", + " Dragon 32\n", + " Ground 32\n", + " Ghost 32\n", + " Dark 31\n", + " Poison 28\n", + " Steel 27\n", + " Fighting 27\n", + " Ice 24\n", + " Fairy 17\n", + " Flying 4\n", + " Name: count, dtype: int64,\n", + " Type 2\n", + " Flying 97\n", + " Ground 35\n", + " Poison 34\n", + " Psychic 33\n", + " Fighting 26\n", + " Grass 25\n", + " Fairy 23\n", + " Steel 22\n", + " Dark 20\n", + " Dragon 18\n", + " Water 14\n", + " Ghost 14\n", + " Ice 14\n", + " Rock 14\n", + " Fire 12\n", + " Electric 6\n", + " Normal 4\n", + " Bug 3\n", + " Name: count, dtype: int64)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[\"Type 1\"].value_counts(), df[\"Type 2\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "df_dragon = df[(df[\"Type 1\"] == 'Dragon') | (df['Type 2'] == 'Dragon')]['HP']\n", + "df_grass = df[(df[\"Type 1\"] == 'Grass') | (df['Type 2'] == 'Grass')]['HP']" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t-statistic: 4.097528915272702\n", + "p-value: 5.090769061176927e-05\n" + ] + } + ], + "source": [ + "t_stat, p_val = st.ttest_ind(df_dragon, df_grass, alternative = 'greater', equal_var=False)\n", + "print(\"t-statistic:\", t_stat)\n", + "print(\"p-value:\", p_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# p_val >= 0.05 → fail to reject the null hypothesis" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/338335915.py:9: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df_plot, x=\"Type\", y=\"HP\", palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Suppose df_dragon and df_grass are Series with HP values\n", + "df_plot = pd.DataFrame({\n", + " \"HP\": pd.concat([df_dragon, df_grass], ignore_index=True),\n", + " \"Type\": [\"Dragon\"] * len(df_dragon) + [\"Grass\"] * len(df_grass)\n", + "})\n", + "\n", + "# Boxplot\n", + "plt.figure(figsize=(8, 5))\n", + "sns.boxplot(data=df_plot, x=\"Type\", y=\"HP\", palette=\"Set2\")\n", + "plt.title(\"HP Distribution: Dragon vs Grass\")\n", + "plt.show()" ] }, { @@ -311,13 +459,312 @@ "- We posit that Legendary Pokemons have different stats (HP, Attack, Defense, Sp.Atk, Sp.Def, Speed) when comparing with Non-Legendary. Choose the propper test and, with 5% significance, comment your findings.\n" ] }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the hypothesis\n", + "\n", + "# H0: Legendary stats = Non-legendary stats\n", + "# H1: Legendary stats != Non-legendary stats\n", + "# Test: ANOVA\n", + "\n", + "# significance level = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HP: F-statistic = 64.58, p-value = 0.0000\n", + "Attack: F-statistic = 108.10, p-value = 0.0000\n", + "Defense: F-statistic = 51.57, p-value = 0.0000\n", + "Sp. Atk: F-statistic = 201.40, p-value = 0.0000\n", + "Sp. Def: F-statistic = 121.83, p-value = 0.0000\n", + "Speed: F-statistic = 95.36, p-value = 0.0000\n" + ] + } + ], + "source": [ + "# Columns to test\n", + "stats_cols = ['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']\n", + "\n", + "# Loop over each stat\n", + "for col in stats_cols:\n", + " # Split groups\n", + " legendary = df[df['Legendary'] == True][col]\n", + " non_legendary = df[df['Legendary'] == False][col]\n", + " \n", + " # One-way ANOVA\n", + " f_stat, p_val = stats.f_oneway(legendary, non_legendary)\n", + "\n", + " print(f\"{col}: F-statistic = {f_stat:.2f}, p-value = {p_val:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# p < 0.05 → reject null → Legendary vs Non-Legendary means differ for all stat." + ] + }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "#code here" + "# Set the hypothesis\n", + "\n", + "# H0: mean(HP) Type: Dragon = mean(HP) Type: Grass\n", + "# H1: mean(HP) Type: Dragon != mean(HP) Type: Grass\n", + "# Test: Multivariate ANOVA, MANOVA\n", + "\n", + "# significance level = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== MANOVA Results ===\n", + " Multivariate linear model\n", + "================================================================\n", + " \n", + "----------------------------------------------------------------\n", + " Intercept Value Num DF Den DF F Value Pr > F\n", + "----------------------------------------------------------------\n", + " Wilks' lambda 0.0592 6.0000 793.0000 2100.8338 0.0000\n", + " Pillai's trace 0.9408 6.0000 793.0000 2100.8338 0.0000\n", + " Hotelling-Lawley trace 15.8953 6.0000 793.0000 2100.8338 0.0000\n", + " Roy's greatest root 15.8953 6.0000 793.0000 2100.8338 0.0000\n", + "----------------------------------------------------------------\n", + " \n", + "----------------------------------------------------------------\n", + " Legendary Value Num DF Den DF F Value Pr > F\n", + "----------------------------------------------------------------\n", + " Wilks' lambda 0.7331 6.0000 793.0000 48.1098 0.0000\n", + " Pillai's trace 0.2669 6.0000 793.0000 48.1098 0.0000\n", + " Hotelling-Lawley trace 0.3640 6.0000 793.0000 48.1098 0.0000\n", + " Roy's greatest root 0.3640 6.0000 793.0000 48.1098 0.0000\n", + "================================================================\n", + "\n", + "\n", + "=== Descriptive statistics per stat ===\n", + "Legendary False True \n", + "HP count 735.000000 65.000000\n", + " mean 67.182313 92.738462\n", + " std 24.808849 21.722164\n", + " min 1.000000 50.000000\n", + " 25% 50.000000 80.000000\n", + " 50% 65.000000 91.000000\n", + " 75% 79.500000 105.000000\n", + " max 255.000000 150.000000\n", + "Attack count 735.000000 65.000000\n", + " mean 75.669388 116.676923\n", + " std 30.490153 30.348037\n", + " min 5.000000 50.000000\n", + " 25% 54.500000 100.000000\n", + " 50% 72.000000 110.000000\n", + " 75% 95.000000 131.000000\n", + " max 185.000000 190.000000\n", + "Defense count 735.000000 65.000000\n", + " mean 71.559184 99.661538\n", + " std 30.408194 28.255131\n", + " min 5.000000 20.000000\n", + " 25% 50.000000 90.000000\n", + " 50% 66.000000 100.000000\n", + " 75% 85.000000 115.000000\n", + " max 230.000000 200.000000\n", + "Sp. Atk count 735.000000 65.000000\n", + " mean 68.454422 122.184615\n", + " std 29.091705 31.104608\n", + " min 10.000000 50.000000\n", + " 25% 45.000000 100.000000\n", + " 50% 65.000000 120.000000\n", + " 75% 85.000000 150.000000\n", + " max 175.000000 194.000000\n", + "Sp. Def count 735.000000 65.000000\n", + " mean 68.892517 105.938462\n", + " std 25.669310 28.827004\n", + " min 20.000000 20.000000\n", + " 25% 50.000000 90.000000\n", + " 50% 65.000000 100.000000\n", + " 75% 85.000000 120.000000\n", + " max 230.000000 200.000000\n", + "Speed count 735.000000 65.000000\n", + " mean 65.455782 100.184615\n", + " std 27.843038 22.952323\n", + " min 5.000000 50.000000\n", + " 25% 45.000000 90.000000\n", + " 50% 64.000000 100.000000\n", + " 75% 85.000000 110.000000\n", + " max 160.000000 180.000000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/3078292662.py:19: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/3078292662.py:19: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/3078292662.py:19: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/3078292662.py:19: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/3078292662.py:19: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/3078292662.py:19: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Columns to compare\n", + "stats_cols = ['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']\n", + "\n", + "# 1️⃣ MANOVA\n", + "# Use Q(...) for column names with spaces\n", + "formula = 'HP + Attack + Defense + Q(\"Sp. Atk\") + Q(\"Sp. Def\") + Speed ~ Legendary'\n", + "maov = MANOVA.from_formula(formula, data=df)\n", + "print(\"=== MANOVA Results ===\")\n", + "print(maov.mv_test())\n", + "\n", + "# 2️⃣ Descriptive statistics per group\n", + "desc = df.groupby('Legendary')[stats_cols].describe().T\n", + "print(\"\\n=== Descriptive statistics per stat ===\")\n", + "print(desc)\n", + "\n", + "# 3️⃣ Boxplots for each stat\n", + "for col in stats_cols:\n", + " plt.figure(figsize=(6,4))\n", + " sns.boxplot(data=df, x='Legendary', y=col, palette=\"Set2\")\n", + " plt.title(f'{col} by Legendary Status')\n", + " plt.show()" ] }, { @@ -337,7 +784,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -453,7 +900,7 @@ "4 624.0 262.0 1.9250 65500.0 " ] }, - "execution_count": 5, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -483,22 +930,135 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Set the hypothesis\n", + "\n", + "# H0: \"close\" median_house_value > \"far\" median_house_value\n", + "# H1: \"close\" median_house_value =< \"far\" median_house_value\n", + "# Test: two-sample T-test\n", + "\n", + "# significance level = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "# Function to calculate Euclidean distance\n", + "def euclidean_distance(lon1, lat1, lon2, lat2):\n", + " return np.sqrt((lon1 - lon2)**2 + (lat1 - lat2)**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# School coordinates\n", + "school_lon, school_lat = -118, 34\n", + "\n", + "# Hospital coordinates\n", + "hospital_lon, hospital_lat = -122, 37\n", + "\n", + "# Compute distances\n", + "df['dist_school'] = euclidean_distance(df['longitude'], df['latitude'], school_lon, school_lat)\n", + "df['dist_hospital'] = euclidean_distance(df['longitude'], df['latitude'], hospital_lon, hospital_lat)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# Boolean flag if house is close to school or hospital\n", + "# True → close\n", + "# False → far\n", + "\n", + "df['close'] = ((df['dist_school'] < 0.50) | (df['dist_hospital'] < 0.50))" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t-statistic: 37.992330214201516\n", + "p-value: 1.5032478884296307e-301\n" + ] + } + ], + "source": [ + "# Split groups\n", + "close_houses = df[df['close']]['median_house_value']\n", + "far_houses = df[~df['close']]['median_house_value'] # The tilde ~ is the logical NOT operator in pandas\n", + " # So ~df['close'] gives all the houses that are NOT close\n", + "\n", + "# Welch's t-test (default two-sided)\n", + "t_stat, p_val = stats.ttest_ind(close_houses, far_houses, alternative = 'greater', equal_var=False)\n", + "\n", + "print(\"t-statistic:\", t_stat)\n", + "print(\"p-value:\", p_val)" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# p ≥ 0.05 → fail to reject null -> close houses have higher median_house_value" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/dr/39536wgj4mn3x17g766yjxlr0000gn/T/ipykernel_51601/4279124066.py:2: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(data=df, x='close', y='median_house_value', palette=\"Set2\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(6,4))\n", + "sns.boxplot(data=df, x='close', y='median_house_value', palette=\"Set2\")\n", + "plt.xticks([0,1], ['Far', 'Close'])\n", + "plt.title(\"House Values: Close vs Far from School/Hospital\")\n", + "plt.show()" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -512,9 +1072,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }