From 299ba12b3b3219bed35fce5d4a2c9a4f1d60ba07 Mon Sep 17 00:00:00 2001 From: Samuel Simeone Date: Sat, 9 Oct 2021 19:25:55 -0400 Subject: [PATCH] lab_bayesian_statistics [Samuel Simeone] --- .../.ipynb_checkpoints/main-checkpoint.ipynb | 532 ++++++++++++++++++ your-code/main.ipynb | 367 ++++++++++-- 2 files changed, 867 insertions(+), 32 deletions(-) create mode 100644 your-code/.ipynb_checkpoints/main-checkpoint.ipynb diff --git a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb new file mode 100644 index 0000000..a774603 --- /dev/null +++ b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb @@ -0,0 +1,532 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Intro to Bayesian Statistics Lab\n", + "\n", + "Complete the following set of exercises to solidify your knowledge of Bayesian statistics and Bayesian data analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Cookie Problem\n", + "\n", + "Suppose we have two bowls of cookies. Bowl 1 contains 30 vanilla cookies and 10 chocolate cookies. Bowl 2 contains 20 of each. You randomly pick one cookie out of one of the bowls, and it is vanilla. Use Bayes Theorem to calculate the probability that the vanilla cookie you picked came from Bowl 1?" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6\n" + ] + } + ], + "source": [ + "# Probabilidad de que la galleta de vainilla obtenida provenga del Bowl 1.\n", + "\n", + "# P(A|B) = P(B|A)P(A)/P(B)\n", + "\n", + "prob = (3/4)*(1/2)/(((3/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the probability that it came from Bowl 2?" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4\n" + ] + } + ], + "source": [ + "prob = (1/2)*(1/2)/(((3/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What if the cookie you had picked was chocolate? What are the probabilities that the chocolate cookie came from Bowl 1 and Bowl 2 respectively?" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3333333333333333\n" + ] + } + ], + "source": [ + "# Bowl 1\n", + "\n", + "prob = (1/4)*(1/2)/(((1/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6666666666666666\n" + ] + } + ], + "source": [ + "# Bowl 2\n", + "\n", + "prob = (1/2)*(1/2)/(((1/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Candy Problem\n", + "\n", + "Suppose you have two bags of candies:\n", + "\n", + "- In Bag 1, the mix of colors is:\n", + " - Brown - 30%\n", + " - Yellow - 20%\n", + " - Red - 20%\n", + " - Green - 10%\n", + " - Orange - 10%\n", + " - Tan - 10%\n", + " \n", + "- In Bag 2, the mix of colors is:\n", + " - Blue - 24%\n", + " - Green - 20%\n", + " - Orange - 16%\n", + " - Yellow - 14%\n", + " - Red - 13%\n", + " - Brown - 13%\n", + " \n", + "Not knowing which bag is which, you randomly draw one candy from each bag. One is yellow and one is green. What is the probability that the yellow one came from the Bag 1?\n", + "\n", + "*Hint: For the likelihoods, you will need to multiply the probabilities of drawing yellow from one bag and green from the other bag and vice versa.*" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7407407407407408" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A = El amarillo es del saco 1\n", + "# B = Se sacaron dos caramelos. Uno amarilla y otro verde\n", + "\n", + "# ----- P(A|B) = P(B|A)*P(A)/P(B) ----- \n", + "\n", + "# P(B|A) = Probabilidad de sacar un caramelo amarillo y otro verde dado que el amarillo vino del saco 1\n", + "# P(A) = Probabilidad de que el amarillo es del saco 1\n", + "# P(B) = Probabilidad de sacar un caramelo verde y otro amarillo\n", + "\n", + "# P(A) tenemos que tomar en cuenta de que para que el caramelo amarillo sea del saco 1, tenemos que tomar primero la\n", + "# probabilidad de escoger ese saco y luego de sacar el caramelo\n", + "\n", + "prob = (0.2 * (1/2)*(0.2)) / ((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the probability that the yellow candy came from Bag 2?" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.25925925925925924" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A = El amarillo es del saco 2\n", + "# B = Se sacaron dos caramelos. Uno amarilla y otro verde\n", + "\n", + "# ----- P(A|B) = P(B|A)*P(A)/P(B) ----- \n", + "\n", + "# P(B|A) = Probabilidad de sacar un caramelo amarillo y otro verde dado que el amarillo vino del saco 2\n", + "# P(A) = Probabilidad de que el amarillo es del saco 2\n", + "# P(B) = Probabilidad de sacar un caramelo verde y otro amarillo\n", + "\n", + "prob = ((0.1) * (1/2)*(0.14))/((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What are the probabilities that the green one came from Bag 1 and Bag 2 respectively?" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.25925925925925924" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A = El verde es del saco 1\n", + "# B = Se sacaron dos caramelos. Uno amarilla y otro verde\n", + "\n", + "# ----- P(A|B) = P(B|A)*P(A)/P(B) ----- \n", + "\n", + "# P(B|A) = Probabilidad de sacar un caramelo amarillo y otro verde dado que el verde vino del saco 1\n", + "# P(A) = Probabilidad de que el verde es del saco 1\n", + "# P(B) = Probabilidad de sacar un caramelo verde y otro amarillo\n", + "\n", + "# Bag1\n", + "\n", + "prob = ((0.14) * (1/2)*(0.1))/((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7407407407407408" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Se procede con la misma logica ya explicada anteriormente.\n", + "\n", + "# Bag2\n", + "\n", + "prob = ((0.2) * (1/2)*(0.2))/((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Monty Hall Problem\n", + "\n", + "Suppose you are a contestant on the popular game show *Let's Make a Deal*. The host of the show (Monty Hall) presents you with three doors - Door A, Door B, and Door C. He tells you that there is a sports car behind one of them and if you choose the correct one, you win the car!\n", + "\n", + "You select Door A, but then Monty makes things a little more interesting. He opens Door B to reveal that there is no sports car behind it and asks you if you would like to stick with your choice of Door A or switch your choice to Door C. Given this new information, what are the probabilities of you winning the car if you stick with Door A versus if you switch to Door C?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La probabilidad de que este detras de la puerta A es 0.3333333333333333\n", + "La probabilidad de que este detras de la puerta C es 0.6666666666666666\n" + ] + } + ], + "source": [ + "# La probabilidad de obtener un carro antes de que la puerta B se abre es de 1/3\n", + "\n", + "# A = El carro esta en la puerta A\n", + "# B = Monty abre la puerta B\n", + "# P(A|B) = Probabilidad de ganar el carro con la puerta A dado que Monty abre la puerta B\n", + "\n", + "# P(B|A) = Probabilidad de que Monty abra la puerta B dado que el carro esta en la puerta A\n", + "# P(A) = Probabilidad de que el carro este en la puerta A\n", + "# P(B) = Probabilidad de que Monty abra la puerta B. \n", + "\n", + "# Esto es dificil de entender ya que se tienen que considerar varias cosas:\n", + "# .- Suponiendo que el carro esta en la puerta A. Si es cogemos A monty puede escoger B o C para abrir\n", + "# .- Pero si escogemos la puerta C monty solo puede escoger la puerta B ya que no puede abrir la puerta A ya que ahi se\n", + "# encuentra el carro.\n", + "\n", + "prob_a = (1/2) * (1/3) / ((1/3)*(1/2) + (1/3)*(1))\n", + "\n", + "# Para el caso C solo cambia que evento A = El carro NO esta detras de la puerta A\n", + "prob_c = (1/2) * (2/3) / ((1/3)*(1/2) + (1/3)*(1))\n", + "\n", + "print(f'La probabilidad de que este detras de la puerta A es {prob_a}')\n", + "print(f'La probabilidad de que este detras de la puerta C es {prob_c}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Bayesian Analysis \n", + "\n", + "Suppose you work for a landscaping company, and they want to advertise their service online. They create an ad and sit back waiting for the money to roll in. On the first day, the ad sends 100 visitors to the site and 14 of them sign up for landscaping services. Create a generative model to come up with the posterior distribution and produce a visualization of what the posterior distribution would look like given the observed data." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "def generative_model(proba_subs):\n", + " subs = np.random.binomial(100, proba_subs)\n", + " return subs\n", + "\n", + "\n", + "n_sends = 100_000\n", + "prior = pd.Series(np.random.uniform(0, 1, size=n_sends))\n", + "\n", + "subs_page = []\n", + "for i in prior:\n", + " subs_page.append(generative_model(i))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Obtenemos una distribucion Uniforme" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Produce a set of descriptive statistics for the posterior distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "posteriori = prior[list(map(lambda x: x==14, subs_page))]\n", + "sns.histplot(posteriori, kde=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the 90% credible interval range?" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-inf, 0.19122953329080777)\n" + ] + } + ], + "source": [ + "# Intervalos de confianza del 90% izquierda\n", + "print(f'(-inf, {np.quantile(posteriori, 0.9)})')" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.103207820237051, inf)\n" + ] + } + ], + "source": [ + "# Intervalos de confianza del 90% derecha\n", + "print(f'({np.quantile(posteriori, 0.1)}, inf)')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0943068763719174, 0.20368452241594717\n" + ] + } + ], + "source": [ + "# Intervalos de confianza del 90% central\n", + "print(f'{np.quantile(posteriori, 0.05)}, {np.quantile(posteriori, 0.95)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the Maximum Likelihood Estimate?" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.14795797830973084" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(posteriori) # El posteriori" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/your-code/main.ipynb b/your-code/main.ipynb index 95bfcb9..a774603 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -11,13 +11,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" ] }, { @@ -31,10 +32,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6\n" + ] + } + ], + "source": [ + "# Probabilidad de que la galleta de vainilla obtenida provenga del Bowl 1.\n", + "\n", + "# P(A|B) = P(B|A)P(A)/P(B)\n", + "\n", + "prob = (3/4)*(1/2)/(((3/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] }, { "cell_type": "markdown", @@ -45,10 +61,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.4\n" + ] + } + ], + "source": [ + "prob = (1/2)*(1/2)/(((3/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] }, { "cell_type": "markdown", @@ -59,10 +86,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3333333333333333\n" + ] + } + ], + "source": [ + "# Bowl 1\n", + "\n", + "prob = (1/4)*(1/2)/(((1/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.6666666666666666\n" + ] + } + ], + "source": [ + "# Bowl 2\n", + "\n", + "prob = (1/2)*(1/2)/(((1/4)*(1/2)) + ((1/2)*(1/2)))\n", + "print(prob)" + ] }, { "cell_type": "markdown", @@ -95,10 +155,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "0.7407407407407408" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A = El amarillo es del saco 1\n", + "# B = Se sacaron dos caramelos. Uno amarilla y otro verde\n", + "\n", + "# ----- P(A|B) = P(B|A)*P(A)/P(B) ----- \n", + "\n", + "# P(B|A) = Probabilidad de sacar un caramelo amarillo y otro verde dado que el amarillo vino del saco 1\n", + "# P(A) = Probabilidad de que el amarillo es del saco 1\n", + "# P(B) = Probabilidad de sacar un caramelo verde y otro amarillo\n", + "\n", + "# P(A) tenemos que tomar en cuenta de que para que el caramelo amarillo sea del saco 1, tenemos que tomar primero la\n", + "# probabilidad de escoger ese saco y luego de sacar el caramelo\n", + "\n", + "prob = (0.2 * (1/2)*(0.2)) / ((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] }, { "cell_type": "markdown", @@ -109,10 +195,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "0.25925925925925924" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A = El amarillo es del saco 2\n", + "# B = Se sacaron dos caramelos. Uno amarilla y otro verde\n", + "\n", + "# ----- P(A|B) = P(B|A)*P(A)/P(B) ----- \n", + "\n", + "# P(B|A) = Probabilidad de sacar un caramelo amarillo y otro verde dado que el amarillo vino del saco 2\n", + "# P(A) = Probabilidad de que el amarillo es del saco 2\n", + "# P(B) = Probabilidad de sacar un caramelo verde y otro amarillo\n", + "\n", + "prob = ((0.1) * (1/2)*(0.14))/((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] }, { "cell_type": "markdown", @@ -123,10 +232,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "0.25925925925925924" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A = El verde es del saco 1\n", + "# B = Se sacaron dos caramelos. Uno amarilla y otro verde\n", + "\n", + "# ----- P(A|B) = P(B|A)*P(A)/P(B) ----- \n", + "\n", + "# P(B|A) = Probabilidad de sacar un caramelo amarillo y otro verde dado que el verde vino del saco 1\n", + "# P(A) = Probabilidad de que el verde es del saco 1\n", + "# P(B) = Probabilidad de sacar un caramelo verde y otro amarillo\n", + "\n", + "# Bag1\n", + "\n", + "prob = ((0.14) * (1/2)*(0.1))/((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7407407407407408" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Se procede con la misma logica ya explicada anteriormente.\n", + "\n", + "# Bag2\n", + "\n", + "prob = ((0.2) * (1/2)*(0.2))/((1/2)*0.2*0.2 + (1/2)*0.1*0.14)\n", + "prob" + ] }, { "cell_type": "markdown", @@ -141,10 +300,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "La probabilidad de que este detras de la puerta A es 0.3333333333333333\n", + "La probabilidad de que este detras de la puerta C es 0.6666666666666666\n" + ] + } + ], + "source": [ + "# La probabilidad de obtener un carro antes de que la puerta B se abre es de 1/3\n", + "\n", + "# A = El carro esta en la puerta A\n", + "# B = Monty abre la puerta B\n", + "# P(A|B) = Probabilidad de ganar el carro con la puerta A dado que Monty abre la puerta B\n", + "\n", + "# P(B|A) = Probabilidad de que Monty abra la puerta B dado que el carro esta en la puerta A\n", + "# P(A) = Probabilidad de que el carro este en la puerta A\n", + "# P(B) = Probabilidad de que Monty abra la puerta B. \n", + "\n", + "# Esto es dificil de entender ya que se tienen que considerar varias cosas:\n", + "# .- Suponiendo que el carro esta en la puerta A. Si es cogemos A monty puede escoger B o C para abrir\n", + "# .- Pero si escogemos la puerta C monty solo puede escoger la puerta B ya que no puede abrir la puerta A ya que ahi se\n", + "# encuentra el carro.\n", + "\n", + "prob_a = (1/2) * (1/3) / ((1/3)*(1/2) + (1/3)*(1))\n", + "\n", + "# Para el caso C solo cambia que evento A = El carro NO esta detras de la puerta A\n", + "prob_c = (1/2) * (2/3) / ((1/3)*(1/2) + (1/3)*(1))\n", + "\n", + "print(f'La probabilidad de que este detras de la puerta A es {prob_a}')\n", + "print(f'La probabilidad de que este detras de la puerta C es {prob_c}')" + ] }, { "cell_type": "markdown", @@ -157,10 +348,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def generative_model(proba_subs):\n", + " subs = np.random.binomial(100, proba_subs)\n", + " return subs\n", + "\n", + "\n", + "n_sends = 100_000\n", + "prior = pd.Series(np.random.uniform(0, 1, size=n_sends))\n", + "\n", + "subs_page = []\n", + "for i in prior:\n", + " subs_page.append(generative_model(i))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Obtenemos una distribucion Uniforme" + ] }, { "cell_type": "markdown", @@ -171,10 +381,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "posteriori = prior[list(map(lambda x: x==14, subs_page))]\n", + "sns.histplot(posteriori, kde=True)" + ] }, { "cell_type": "markdown", @@ -185,10 +421,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-inf, 0.19122953329080777)\n" + ] + } + ], + "source": [ + "# Intervalos de confianza del 90% izquierda\n", + "print(f'(-inf, {np.quantile(posteriori, 0.9)})')" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0.103207820237051, inf)\n" + ] + } + ], + "source": [ + "# Intervalos de confianza del 90% derecha\n", + "print(f'({np.quantile(posteriori, 0.1)}, inf)')" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0943068763719174, 0.20368452241594717\n" + ] + } + ], + "source": [ + "# Intervalos de confianza del 90% central\n", + "print(f'{np.quantile(posteriori, 0.05)}, {np.quantile(posteriori, 0.95)}')" + ] }, { "cell_type": "markdown", @@ -197,6 +480,26 @@ "What is the Maximum Likelihood Estimate?" ] }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.14795797830973084" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(posteriori) # El posteriori" + ] + }, { "cell_type": "code", "execution_count": null, @@ -221,7 +524,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.8.8" } }, "nbformat": 4,