diff --git a/your-code/main.ipynb b/your-code/main.ipynb index cdc1acb..bde4abc 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -14,12 +14,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "# import numpy and pandas\n", - "\n" + "import pandas as pd\n", + "import numpy as np\n", + "from scipy.stats import ttest_ind\n" ] }, { @@ -35,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 71, "metadata": {}, "outputs": [], "source": [ @@ -53,11 +55,153 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
#NameType 1Type 2TotalHPAttackDefenseSp. AtkSp. DefSpeedGenerationLegendary
01BulbasaurGrassPoison3184549496565451False
12IvysaurGrassPoison4056062638080601False
23VenusaurGrassPoison525808283100100801False
33VenusaurMega VenusaurGrassPoison62580100123122120801False
44CharmanderFireNaN3093952436050651False
\n", + "
" + ], + "text/plain": [ + " # Name Type 1 Type 2 Total HP Attack Defense \\\n", + "0 1 Bulbasaur Grass Poison 318 45 49 49 \n", + "1 2 Ivysaur Grass Poison 405 60 62 63 \n", + "2 3 Venusaur Grass Poison 525 80 82 83 \n", + "3 3 VenusaurMega Venusaur Grass Poison 625 80 100 123 \n", + "4 4 Charmander Fire NaN 309 39 52 43 \n", + "\n", + " Sp. Atk Sp. Def Speed Generation Legendary \n", + "0 65 65 45 1 False \n", + "1 80 80 60 1 False \n", + "2 100 100 80 1 False \n", + "3 122 120 80 1 False \n", + "4 60 50 65 1 False " + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pokemon.head()\n", "\n" ] }, @@ -70,12 +214,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", - "\n" + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Legendary\n", + "False 735\n", + "True 65\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "legendary = pokemon[pokemon['Legendary'] == True].shape[0]\n", + "non_legendary = pokemon[pokemon['Legendary'] == False].shape[0]\n", + "pokemon['Legendary'].value_counts()\n" ] }, { @@ -87,12 +246,40 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", - "\n" + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Legendary Pokémon:\n", + "Mean Total Points: 637.3846153846154\n", + "Standard Deviation: 60.93738905315344\n", + "\n", + "Non-Legendary Pokémon:\n", + "Mean Total Points: 417.21360544217686\n", + "Standard Deviation: 106.76041745713005\n" + ] + } + ], + "source": [ + "legendary_ = pokemon[pokemon['Legendary'] == True]\n", + "non_legendary_ = pokemon[pokemon['Legendary'] == False]\n", + "\n", + "legendary_mean = legendary_['Total'].mean()\n", + "legendary_std = legendary_['Total'].std()\n", + "\n", + "non_legendary_mean = non_legendary_['Total'].mean()\n", + "non_legendary_std = non_legendary_['Total'].std()\n", + "\n", + "print(\"Legendary Pokémon:\")\n", + "print(f\"Mean Total Points: {legendary_mean}\")\n", + "print(f\"Standard Deviation: {legendary_std}\")\n", + "\n", + "print(\"\\nNon-Legendary Pokémon:\")\n", + "print(f\"Mean Total Points: {non_legendary_mean}\")\n", + "print(f\"Standard Deviation: {non_legendary_std}\")\n" ] }, { @@ -106,12 +293,113 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", - "\n" + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Two-Sample T-Test:\n", + "Test Statistic (t): 25.83\n", + "P-Value: 0.0000\n", + "Reject the Null Hypothesis: There is a significant difference between the total points of legendary and non-legendary Pokémon.\n" + ] + } + ], + "source": [ + "# test for independent variables\n", + "t_stat, p_value = ttest_ind(legendary_['Total'], non_legendary_['Total'], equal_var=False)\n", + "print(\"\\nTwo-Sample T-Test:\")\n", + "print(f\"Test Statistic (t): {t_stat:.2f}\")\n", + "print(f\"P-Value: {p_value:.4f}\")\n", + "\n", + "alpha = 0.05\n", + "if p_value < alpha:\n", + " print(\"Reject the Null Hypothesis: There is a significant difference between the total points of legendary and non-legendary Pokémon.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: There is no significant difference between the total points of legendary and non-legendary Pokémon.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Two-Sample T-Test (Right-Tailed):\n", + "Test Statistic (t): 25.83\n", + "Right-Tailed P-Value: 0.0000\n", + "Critical Value: 1.65\n", + "Reject the Null Hypothesis: Legendary Pokémon have significantly greater total points than non-legendary Pokémon.\n" + ] + } + ], + "source": [ + "from scipy.stats import ttest_ind, t\n", + "\n", + "t_stat, _ = ttest_ind(legendary_['Total'], non_legendary_['Total'], equal_var=False)\n", + "\n", + "# degrees of fredom to calculate the critical value\n", + "n1 = len(legendary_['Total'])\n", + "n2 = len(non_legendary_['Total'])\n", + "df = (n1 - 1) + (n2 - 1) \n", + "\n", + "p_value_right_tailed = 1 - t.cdf(t_stat, df)\n", + "\n", + "alpha = 0.05\n", + "critical_value = t.ppf(1 - alpha, df)\n", + "\n", + "\n", + "print(\"\\nTwo-Sample T-Test (Right-Tailed):\")\n", + "print(f\"Test Statistic (t): {t_stat:.2f}\")\n", + "print(f\"Right-Tailed P-Value: {p_value_right_tailed:.4f}\")\n", + "print(f\"Critical Value: {critical_value:.2f}\")\n", + "\n", + "if p_value_right_tailed < alpha:\n", + " print(\"Reject the Null Hypothesis: Legendary Pokémon have significantly greater total points than non-legendary Pokémon.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: Legendary Pokémon do not have significantly greater total points than non-legendary Pokémon.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(-5, 5, 1000) \n", + "y = t.pdf(x, df) \n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x, y, label=\"t-Distribution\", color=\"blue\")\n", + "plt.fill_between(x, y, where=(x > critical_value), color=\"red\", alpha=0.3, label=\"Rejection Region\")\n", + "plt.axvline(t_stat, color='green', linestyle='--', label=f\"Test Statistic (t) = {t_stat:.2f}\")\n", + "plt.axvline(critical_value, color='orange', linestyle='--', label=f\"Critical Value (t) = {critical_value:.2f}\")\n", + "plt.title(\"Right-Tailed T-Test Visualization\")\n", + "plt.xlabel(\"t-Statistic\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "\n", + "\n", + "plt.grid(True)\n", + "plt.show()" ] }, { @@ -123,12 +411,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 78, "metadata": {}, "outputs": [], "source": [ - "# Your conclusions here:\n", - "\n" + "# the t-test two side statitics show that the legendary and non-legendary have diferent average total points. \n", + "# the p-value is smaller than the alpha so we reject the null hypothesis\n", + "# the t-test falls into a critical zone (right tail) " ] }, { @@ -140,12 +429,42 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", - "\n" + "execution_count": 79, + "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", + "Rock 44\n", + "Electric 44\n", + "Ground 32\n", + "Ghost 32\n", + "Dragon 32\n", + "Dark 31\n", + "Poison 28\n", + "Fighting 27\n", + "Steel 27\n", + "Ice 24\n", + "Fairy 17\n", + "Flying 4\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type_counts = pokemon['Type 1'].value_counts()\n", + "type_counts\n" ] }, { @@ -157,11 +476,41 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Water Pokémon:\n", + "Mean Total Points: 430.45535714285717\n", + "Standard Deviation: 113.1882660643146\n", + "\n", + "Non-Water Pokémon:\n", + "Mean Total Points: 435.85901162790697\n", + "Standard Deviation: 121.0916823020807\n" + ] + } + ], + "source": [ + "water_pokemon = pokemon[pokemon['Type 1'] == 'Water']\n", + "non_water_pokemon = pokemon[pokemon['Type 1'] != 'Water']\n", + "\n", + "water_mean = water_pokemon['Total'].mean()\n", + "water_std = water_pokemon['Total'].std()\n", + "\n", + "non_water_mean = non_water_pokemon['Total'].mean()\n", + "non_water_std = non_water_pokemon['Total'].std()\n", + "\n", + "print(\"Water Pokémon:\")\n", + "print(f\"Mean Total Points: {water_mean}\")\n", + "print(f\"Standard Deviation: {water_std}\")\n", + "\n", + "print(\"\\nNon-Water Pokémon:\")\n", + "print(f\"Mean Total Points: {non_water_mean}\")\n", + "print(f\"Standard Deviation: {non_water_std}\")\n", + "\n", "\n" ] }, @@ -174,12 +523,33 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Two-Sample T-Test (Equal Variance):\n", + "Test Statistic (t): -0.44\n", + "P-Value: 0.6587\n", + "Fail to Reject the Null Hypothesis: There is no significant difference between water and non-water Pokémon total points.\n" + ] + } + ], "source": [ - "# Your code here:\n", - "\n" + "\n", + "t_stat_water, p_value_water = ttest_ind(water_pokemon['Total'], non_water_pokemon['Total'], equal_var=True)\n", + "\n", + "print(\"\\nTwo-Sample T-Test (Equal Variance):\")\n", + "print(f\"Test Statistic (t): {t_stat_water:.2f}\")\n", + "print(f\"P-Value: {p_value_water:.4f}\")\n", + "\n", + "if p_value_water < alpha:\n", + " print(\"Reject the Null Hypothesis: There is a significant difference between water and non-water Pokémon total points.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: There is no significant difference between water and non-water Pokémon total points.\")" ] }, { @@ -191,11 +561,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ - "# Your conclusions here:\n", + "# p-value is grather of alpha so we fail to reject the null hypothesis.\n", + "\n", "\n" ] }, @@ -210,11 +581,34 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Paired T-Test (Defense vs Attack):\n", + "Test Statistic (t): -4.33\n", + "P-Value: 0.0000\n", + "Reject the Null Hypothesis: There is a significant difference between defense and attack scores.\n" + ] + } + ], + "source": [ + "from scipy.stats import ttest_rel\n", + "\n", + "t_stat_defense_attack, p_value_defense_attack = ttest_rel(pokemon['Defense'], pokemon['Attack'])\n", + "\n", + "print(\"\\nPaired T-Test (Defense vs Attack):\")\n", + "print(f\"Test Statistic (t): {t_stat_defense_attack:.2f}\")\n", + "print(f\"P-Value: {p_value_defense_attack:.4f}\")\n", + "\n", + "if p_value_defense_attack < alpha:\n", + " print(\"Reject the Null Hypothesis: There is a significant difference between defense and attack scores.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: There is no significant difference between defense and attack scores.\")\n", "\n" ] }, @@ -231,8 +625,7 @@ "metadata": {}, "outputs": [], "source": [ - "# Your conclusions here:\n", - "\n" + "# We reject the null hypothesis since th p-value is smallar than the alpha (falls into a left tail)" ] }, { @@ -244,11 +637,33 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Paired T-Test (Special Defense vs Special Attack):\n", + "Test Statistic (t): -0.85\n", + "P-Value: 0.3934\n", + "Fail to Reject the Null Hypothesis: There is no significant difference between special defense and special attack.\n" + ] + } + ], + "source": [ + "t_stat_sp_defense_attack, p_value_sp_defense_attack = ttest_rel(pokemon['Sp. Def'], pokemon['Sp. Atk'])\n", + "\n", + "print(\"\\nPaired T-Test (Special Defense vs Special Attack):\")\n", + "print(f\"Test Statistic (t): {t_stat_sp_defense_attack:.2f}\")\n", + "print(f\"P-Value: {p_value_sp_defense_attack:.4f}\")\n", + "\n", + "if p_value_sp_defense_attack < alpha:\n", + " print(\"Reject the Null Hypothesis: There is a significant difference between special defense and special attack.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: There is no significant difference between special defense and special attack.\")\n", + "\n", "\n" ] }, @@ -261,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "metadata": {}, "outputs": [], "source": [ @@ -280,11 +695,37 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "One-Sample T-Test (Difference between Defense and Attack):\n", + "Test Statistic (t): -4.33\n", + "P-Value: 0.0000\n", + "Reject the Null Hypothesis: The difference between defense and attack is significantly different from zero.\n" + ] + } + ], + "source": [ + "from scipy.stats import ttest_1samp\n", + "\n", + "difference_defense_attack = pokemon['Defense'] - pokemon['Attack']\n", + "\n", + "t_stat_diff, p_value_diff = ttest_1samp(difference_defense_attack, 0)\n", + "\n", + "print(\"\\nOne-Sample T-Test (Difference between Defense and Attack):\")\n", + "print(f\"Test Statistic (t): {t_stat_diff:.2f}\")\n", + "print(f\"P-Value: {p_value_diff:.4f}\")\n", + "\n", + "if p_value_diff < alpha:\n", + " print(\"Reject the Null Hypothesis: The difference between defense and attack is significantly different from zero.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: The difference between defense and attack is not significantly different from zero.\")\n", + "\n", " \n", " " ] @@ -304,10 +745,78 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Contingency Table:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Type 1FalseTrue
Legendary
False627108
True614
\n", + "
" + ], + "text/plain": [ + "Type 1 False True \n", + "Legendary \n", + "False 627 108\n", + "True 61 4" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Your code here:\n", - "\n" + "\n", + "contingency_table = pd.crosstab(pokemon['Legendary'], pokemon['Type 1'] == 'Water')\n", + "\n", + "print(\"\\nContingency Table:\")\n", + "contingency_table" ] }, { @@ -319,12 +828,34 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:\n", - "\n" + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Chi-Square Test:\n", + "Chi-Square Statistic: 2.94\n", + "P-Value: 0.0863\n", + "Fail to Reject the Null Hypothesis: There is no significant relationship between whether a Pokémon is Legendary and whether it is Water-type.\n" + ] + } + ], + "source": [ + "from scipy.stats import chi2_contingency\n", + "\n", + "chi2_stat, p_value_chi2, dof, expected = chi2_contingency(contingency_table)\n", + "\n", + "print(\"\\nChi-Square Test:\")\n", + "print(f\"Chi-Square Statistic: {chi2_stat:.2f}\")\n", + "print(f\"P-Value: {p_value_chi2:.4f}\")\n", + "\n", + "if p_value_chi2 < alpha:\n", + " print(\"Reject the Null Hypothesis: There is a significant relationship between whether a Pokémon is Legendary and whether it is Water-type.\")\n", + "else:\n", + " print(\"Fail to Reject the Null Hypothesis: There is no significant relationship between whether a Pokémon is Legendary and whether it is Water-type.\")" ] }, { @@ -340,16 +871,9 @@ "metadata": {}, "outputs": [], "source": [ - "# Your answer here:\n", - "\n" + "# No, we fail to reject the hypothesis since the p-value is greather than the alpha \n", + "# The two variables appear to be independent in this case." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -368,7 +892,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.12.8" } }, "nbformat": 4,