Notas Curso de Estadistica Computacional

Curso de estadistica computacional
Autor Pablo Pérez
Date
Fecha de Creación Jan 15, 2021 608 PM
Notes
Status Finished
Introducción a la Programación Dinámica

Optimización de Fibonacci
Caminos Aleatorios
Aleatoriedad en Python
Introducción a la programación Estocaśtica
Cálculo de Probabilidades
Ley del complemento
Ley multiplicativa
Ley Aditiva
Simulación de probabilidades
Ley de los Grandes Números
Simulando!
Inferencia Estadistica
Falacia del Apostador
Media
Varianza y Deviación Estándar
Varianza
Desviación Estandar
Recap
Distribución Normal
Regla Empírica
Simulaciones de Montecarlo
Simulación de Barajas
Cálculo de PI
Muestreo de intervalos de confianza
Muestreo
Tipos de muestreo probabilistico
Teorema del límite central
Datos Experimentales
Regresión Lineal
Conclusiones
Introducción a la Programación Dinámica

Richard Bellman
No relacionada con su nombre
Tecnica muy usada para optimizar ciertos problemas, los cuales poseén:
Una Subestructura Óptima: Una solución global que se puede encontrar al combinar soluciones óptimas de
subproblemas locales.
Problemas empalmados: Una solución óptima que involucra resolver el mismo problema en varias ocasiones.
Curso de estadistica computacional 1

La optimización es llamada Memorización .
Lo que hace es evitar computos adicionales guardando el resultado de computaciones previas dentro de una estructura
de datos. (diccionarios, set, tuplas)
Normalmente se usa un diccionario donde las consultas se puden hacer en O(1) . O sea, sea cual sea el input o tamaño
de el diccionario siempre va a tardar lo mismo.
Intercambia tiempo por espacio. Este concepto sucede muchas veces en conceptos de la computación. Cuando
queremos optimizar tiempo posiblemente requeramos más espacio, espacio de disco o memoria.
Optimización de Fibonacci
Recordando que los numeros de fibonacci los podemos definir como la siguiente formula.
Fn = Fn−1 + Fn−2
Explicando esta formula podemos resumir que el número de fibonacci se puede obtener si obtenemos el numero de
fibonacci de n-1 y n-2 , y para obtener el número de fibonacci 1 debemos usar la misma formula, o sea, restarle 1 y 2 para
obtenerlo.
Como te das cuenta es un proceso de alta recursividad y a la vez poco eficiente (en tiempo) cuando vamos a números
grandes. Este algoritmo es de big O exponencial. O(2**n) , ya que estamos llamando a la función 2 veces por cada vez. Lo
que significa peligro.
Nuestro trabajo ahora sera optimizar el algoritmo recursivo añadiendole memoization o memorización.
import sys
def fibonacci_recursivo(n):
if n == 1 or n == 0:
return 1
return fibonacci_recursivo(n-1) + fibonacci_recursivo(n-2)
def fibonacci_dinamico(n, memory={}):

if n == 1 or n == 0:
return 1
try:
return memory[n]
except KeyError:
r = fibonacci_dinamico(n-1, memory) + fibonacci_dinamico(n-2, memory)
memory[n] = r
#print(memory)
return r

if __name__ == "__main__":
inp = int(input("N = "))
sys.setrecursionlimit(inp+10)
print(fibonacci_dinamico(inp))
En este codigo definimos la función fibonacci_recursivo y fibonacci_dinammico , lo interesante del fibonacci dinamico es que no
posee las mismas limitaciones del codigo recursivo, se puede decir que su crecimiento es ahora n log n , crece rapido pero
no de manera exponencial como lo hace el codigo recursivo.
Esta optimiziación de crecimiento (en tiempo) es gracias al uso del diccionario memory , el cual le ayuda al sistema a recordar
si el calculo x numero fibonacci ya fue realizado.
Con esto finalizamos la optimización, ya sabemos lo suficiente como para optimizar cualquier codigo recursivo empalmado
poco eficiente gracias a la tecnica de Memorizacion . Empalmado=Que se repite una y otra vez los mismo resultados uhff)
Caminos Aleatorios
Todos los programas hasta ahora han sido deterministas, lo que significa que al mismo input obtenemos el mismo output.
Esta tecnica es una formalización matemática de la trayectoria que resulta de hacer sucesivos pasos aleatorios.
Existen problemas que por su naturaleza incluyen aleatorieadad, lo que significa que incluyen elementos aleatorios y
debemos saber como incorporar estos elementos en nuestros programas.
Con esto nos introducimos a un tipo de simulación muy especifica llamado Caminos Aleatorios .
Tipo de simulación que elige aleatoriamente una decisión dentro de un conjunto de decisiones válidas.
Se utiliza en campos del conocimiento cuando los sistemas no son deterministas e incluyen elementos de aleatoriedad.
Ejemplo, Movimiento Browniano y particulas de humo.
Estos movimientos de particulas de humo se crean dando a la particula movimientos

Golpes aleatorios entre moleculas de agua y polen. validos con esos se aleatoriza y se forma la imagen que vemos.
Nobel Albert Einstein.
Todos estos ejemplos son imposibles de realizar de forma deterministica, dado esto podemos extraer el comportamiento
de una particula y multiplicarlo por miles y poder generar estas simulaciones de colisiones gracias a las nociones de caminos
aleatorios .
Pero no solo podemos simular el movimiento de particulas tambien el de galaxias y planetas.

En ambas simulaciones estamos usando la gravedad, masa y velocidad de cada objeto celeste.
Como sabemos tampoco los caminos aleatorios se limitan al campo de la física.
Cuando queremos simular si una acción sube o baja debemos usar caminos aleatorios, generando así simulación de los
precios de compra/venta en el mercado.
Con estos ejemplos en mente podemos asumir que los caminos aleatorios son una herramiento lagica conceptual bastante
util y poderosa.
Esta estructura fue hecha por el artista Antony Gormley, pero no

precisamente diseñada por el. Este artista con la ayuda de un
algoritmo de caminos aleatorios, el cual le dio las ubicaciones
exactas de donde ubicar cada estructura pudo desarrollar esta
maravilla para los cientificos en general.

Quantum Cloud Sculpture. Estructura de nube cuantica.
Aleatoriedad en Python
Proyecto de los 3 borrachos.
from bokeh.plotting import figure, show
from borracho import BorrachoOlimpico

from campo import Campo
from coordenada import Coordenada
def caminata(campo, borracho, pasos):

inicio = campo.obtener_coordernada(borracho)
for _ in range(pasos):
campo.mover_borracho(borracho)
return inicio.distancia(campo.obtener_coordernada(borracho))
def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):

borracho = tipo_de_borracho(nombre = 'Pablo')
origen = Coordenada(0, 0)
distancias = []
for _ in range(numero_de_intentos):
campo = Campo()
campo.anadir_borracho(borracho, origen)
simulacion_caminata = caminata(campo, borracho, pasos)
distancias.append(round(simulacion_caminata, 1))
return distancias
def graficar(x, y):

grafica = figure(title="Camino Aleatorio", x_axis_label='pasos', y_axis_label='distancia')
grafica.line(x, y, legend='distancia media')
show(grafica)
def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):

distancias_media_por_caminata = []

for pasos in distancias_de_caminata:
distancias = simular_caminata(pasos, numero_de_intentos, tipo_de_borracho)
distancia_media = round(sum(distancias) / len(distancias), 4)
distancia_maxima = max(distancias)
distancia_minima = min(distancias)
distancias_media_por_caminata.append(distancia_media)
print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos}')

print(f'Media = {distancia_media}')
print(f'Maxima = {distancia_maxima}')
print(f'Minima = {distancia_minima}')
graficar(distancias_de_caminata,distancias_media_por_caminata)
if __name__ == '__main__':
distancias_de_caminata = [10, 100, 1000, 10000]
numero_de_intentos = 100
main(distancias_de_caminata, numero_de_intentos, BorrachoOlimpico)
Introducción a la programación Estocaśtica

Un programa es deterministico si cuando introducimos el mismo input recibimos el mismo output. Como la mayoria de
programas que usamos!
Los programas deterministicos son muy importantes, pero existen problemas que no pueden resolverse de esta
manera.
Aquí aparece la programación estocástica, la cual permite introducir aleatoriedad a nuestros programas para crear
simulaciones que permiten resolver otro tipo de problemas. Como lo puede ser el manejo de trafico, simulaciones
financieras, efectos de drogas, vehiculos autonomos, etc..
Los programas estocásticso se aprovechan de que las distribuciones de probabilisticas de un problema se conocen o
pueden ser estimadas.
Ejemplos de un programa determinista: El SO de tu computador.

Ejemplos de un programa estocástico: El sistema de conducción autonoma de los tesla.
Cálculo de Probabilidades
Ya sabiendo que debemos usar la programación estocástica en problemas probabilisticos o problemas que existen con un
elemeneto de aleatoriedad, es importante comprender probabilidades.
La probabilidad es una medida de certidumbre asociada a un evento o suceso futuro y suele expresarse como un
número entre 0 y 1.
Una probabilidad de 0 significa que un suceso jamás sucedera.
Una probabilidad de 1 significa que un suceso está garantizado de suceder en el futuro.
Al hablar de probabilidad preguntamos qué fracción de todos los posibles eventos tiene la propiedad que buscamos.
Por eso es importante poder calcular todas las posibilidades de un evento para entender su probabilidad.
La probabilidad de que un evento suceda y de que no suceda siempre es 1 .
Ley del complemento
P (A) + P (∼ A) = 1
La probabilidad de que ocurra A y la probabilidad de que no ocurra A es igual a 1
Ley multiplicativa
Independiente uno de otro

P (A y B) = P (A) ⋅ P (B)
Probabilidad de que un evento A y otro envento B sucedan.
Una ley general dentro de esta ley es que siempre el resultado de la probabilida de ocurrencia de ambos sucesos es
menor a la de un sucede independiente.
Ponte en el siguiente caso:

¿Cual es la probabilidad de que te guste la musica electronica y te guste programar?
Como dice la ley, siempre va a haber mayor probabilidad de que te guste la música electronica a que te gusten ambos o
que te guste más programar a que te gusten ambos.
Dependientes uno de otro
P (A ÷ B) = P (B ÷ A) ⋅ P (A ÷ B)
Probabilidad de que A y B sucedan si son dependientes del otro.
Ley Aditiva
Mutuamente Exclusivos
P (A o B) = P (A) + P (B)
¿Cual es la probabilidad de que A suceda o que B suceda? Al ser eventos mutuamente exclusivos, o sea, uno a la vez,
se suman ambas probabilidadaes de ocurrencia de los sucesos.
Ejemplo: ¿Cual es la probabilidad de que vaya al supermercado y vaya a un restaurante? Ambos sucecos no pueden
suceder a la vez, dado eso se le denomina mutuamente exclusivos.
No Exclusivos
P (A o B) = P (A) + P (B) − P (A y b)
Y al no ser exclusivos, o sea, que sucedan a la vez, sumamos ambas probabilidades de ocurrencia, P (A) + P (B) y
restamos la probabilidad de que ocurran ambas a la vez P (A y B), lo que seria equivalente a la ley multiplicativa.
P (A y B) = P (A) ⋅ P (B)
Ejemplo: La probabilidad de que este usando mi computador en el día es del 0.5 y la probabilidad de que ese día
amanezca es 1 , con esto podemos pensar que la probabilidad seria 1.5 , pero esto estaria erroneo ya que las
probabilidades son de 0 a 1 , entonces además sabiendo que estos sucedos son no exclusivos, lo que quiere decir que
pueden suceder a la vez, debemos restar la probabilidad de que ocurran ambos eventos a la vez. Y la probabilidad de
que ocurran ambos a la vez es de un 0.5 .
P (A o B) = 0.5 + 1 − 0.5
Esto nos da como resultado 1 , es 100% probable de que ese día amaneza y use mi computador.
Simulación de probabilidades
Al ser las probabilidades un tema algo complejo, lo más facil es crear simulaciónes en nuestra computadora.

Mientras más muestras saquemos de una población más cercanos vamos a estar de los valores correctos o reales.
Conforme el número de intentos vaya al infinito nos vamos a acercar al valor correcto de la probabilidad.
Simulando!

En este codigo simulamos el lanzamiento de x dados n veces. Y al final de la ejecucción obtenemos el promedio de un
suceso. Cuidado! El creciemiento es exponencial O(n**3) .
import random
def tirar_dado(numero_de_tiros):
secuencia_de_tiros = []
for _ in range(numero_de_tiros):
tiro = random.choice( [1, 2, 3, 4, 5, 6] ) # random.randint(1,7)
secuencia_de_tiros.append(tiro)
return secuencia_de_tiros
def main(numero_de_tiros, numero_de_intentos):

tiros = []
secuencia_de_tiros = tirar_dado(numero_de_tiros)
tiros.append(secuencia_de_tiros)
tiros_con_1 = 0
for tiro in tiros:
if 1 not in tiro:
tiros_con_1 += 1
probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
#print(f'Probabilidad de no obtener por lo menos un 1 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1} ')
return probabilidad_tiros_con_1
if __name__ == "__main__":
numero_de_tiros = int(input('Tiros del dado: '))
numero_de_intentos = int(input('Cuantas veces correr simulacion: '))
promedio = []
probabilidad = main(numero_de_tiros, numero_de_intentos)
promedio.append(probabilidad)
promedio = sum(promedio) / len(promedio)
print(f'Promedio de por lo menos no obtener 1 en {numero_de_intentos} tiros = {promedio}')
Inferencia Estadistica
Con las simulaciones podemos calcular las probabilidades de eventos complejos sabiendo las probabilidades de
eventos simples.
¿Qué pasa cuando no sabemos las probabilidades de los eventos simples?
Precisamente como dice el titulo: Las tecnicas de inferencia estadistica nos permiten inferir/concluir las propiedades de
un población a partir de una muestra aleatoria.
"El principio guía de la Inferencia Estadística

es que una muestra aleatoria tiende a exhibir
las mismas proiedades que la población de la
cual fue extraída" - John Guttag
Tenemos una población objetiva y sacamos una muestra representativa y aleatoria (esto debido a que si sesgamos nuestra
muestra nuestras inferencias estaran sesgadas). Ya una vez con la muestra, podremos obtener conclusiones de la
población.

En pruebas independientes repetidas con la misma probabilidad de p de un resultado, la fracción de desviaciones de p
converge a cera conforme las cantidades de pruebas se acerca al infinito.
Resumen: Conforme generamos más y más pruebas la probabilidad de que las pruebas se alejen directamente de la
probabilidad real empieza a ser 0 conforme la cantidad de muestreos se vuelva infinita.
La probabilidad P de que conforme la media X de la población n se acerque a la

media de la población total, conforme el limite se acerca al infinito es igual a 1.
Es decir, la probabilidad de que la media de las muestras sea igual a la media de la población total conforme las muestras
se vuelven infinitas es igual a 1.
Falacia del Apostador

Señala que despues de un evento extremo, ocurrirán eventos menos extremos para nivelar la media.
Ejemplo: Despues de que saque 20 veces un 6 lanzando dados, significa que ahora debo sacar 20 veces 1 para que
más o menos se llegue a la media, que seria 3 .
💡 ESTO ES FALSO, CADA EVENTO ES INDEPENDIENTE
Lo que si sucede es la regresión a la media!
La regresión a la media señala que después de un evento aleatoria extremo, el siguiente evento probablemente sera
menos extremo.
Uno de los ejemplos más claros es la ruleta de montecarlo.
En el casino de montecarlo en 1943 sucedio un evento extremo, sucedio

que la ruleta arrojo 32 rojos concecutivos, entonces la gente en ese casino
penso "Increible, ahora deben venir muchos negros para mantener la
media de mitad rojos y negros", entonces la gente empezo a apostar al
negro todo el tiempo, esto sin saber que la probabilidad de obtener un rojo
o un negro seguiria siendo 50%/50%.
La probabilidad de que surjan 32 negros despues de 32 rojos es bajisima.

Esa noche fue una de las con mayor profit para el casino porque la gente
cayo en la falacia del apostador, envez de entender que iba a suceder una
regresión a la media.
Media
Uno de los elementos más importantes de la inferencia estadistica es el calculo de la media.
Medida d etendencia central
Comúnmente es conocida como el promedio
La media de una población se denota con le simbolo μ (miu). La media de una muestra se denota con X .
xi Significa que tenemos un arreglo de esquices que comienzan en el indice i = 1

y nos vamos a ir al indice n y luego vamos a dividir toda la suma de estos valores
entre el total de valores.

Calculo de media extendido.
Calculo de media.
import random import random

import statistics
def media(X):
return sum(X) / len(X) if __name__ == '__main__':
X = [random.randint(1,21) for i in range(20)]
if __name__ == '__main__': mu = statistics.mean(X)
mu = media(X) print(X)
print(mu)
print(X)
print(mu)
Esta formula reside en la libreria statistics en el método

mean .
La formula se ve compleja, pero en codigo es muy simple.
Varianza y Deviación Estándar

Mientras que la media nos dice donde se ubicacn la mayoria de valores, siendo una medida de tendencia central.
La varianza y desviación estandar son medidas de propagación. Que tan a diespersos u homogeneos a la media se
encuentran los valores.
La varianza o desviación media siempre debe entenderse con respecto a la media.
Varianza
Nos permite entender que tan dispersos estan los datos.
Comenzamos recorriendo el array xi y por cada uno de los elementos de array lo

restamos con la media μ y todo esto se eleva al cuadrado, para no tener ningun
negativo y que nuestra dispersión sea mayor mientras mayor alejamiento y menor
mientras menor alejamiento. Y luego dividimos esta diferencia al cuadrado por el
número de elementos.
Desviación Estandar
La desviación estándar es la raíz cuadrada de la varianza.
Nos permite entender la propagación y también se debe entender siempre relacionado a la media.
La ventaja sobre la varianza es que la desviación estándar está en las misma unidades que la media.
El calculo de la desviación estandar es simplemente el calculo de la varianza

llevada al cuadrado.
import random
import math

def media(X):
return sum(X) / len(X)
def varianza(X):
mu = media(X)
acumulador = 0
for x in X:
acumulador += (x - mu)**2
return acumulador / len(X)
def desviacion_estandar(X):
return math.sqrt(varianza(X))
if __name__ == '__main__':
mu = media(X)
sigma_cuadrado = varianza(X)
sigma = desviacion_estandar(X)
print(f'Arreglo: {X}')
print(f'Media: {mu}')
print(f'Varianza: {sigma_cuadrado}')
print(f'Desviacion Estandar: {sigma}')
Recap
Mientras la media es una medida de tendencia central, los datos pueden esparcirse mucho o mantenerse muy cercanos a la
media, y estas medidas nos las va a otorgar la varianza y la desviación estandar.
Distribución Normal
Es una de las distribuciones más recurrentes en cualquier ambito. ¿Cual es el lenguaje de programación del año?,
¿Cuales son tus ingresos?
Se define completamente por su media y su desviación estandar.
Permite calcular la probabilidad de ocurrencia de algo con la regla empirica.
Podemos convertir una distribución que no es normal a normal.
Poseé forma de campana
Fijate que solo debemos obtener la media y la desviación estandar como parametros para
poder calcular la distribución normal.
Simetria con respecto a al media
Ambas distribuciones tienen la media en 10 y la primera la

desviación estandar en 1 y la segunda en 3 . Como te has dado
cuenta con esta imagen, a menor desviación media más
homogenios estan los datos y a mayor desviación media más
heterogeneos estan los datos.
Un buen ejemplo para esto serian las finanzas, cuando analizas una
inversión quieres saber la media del retorno que vas a recibir y la
desviación estandar te dira el riesgo de esa inversión, si varia
mucho o que tan disperso será.
Ejemplo de distribución normal
Regla Empírica

Tambien conocida como la regla 65-95-99.7 .
Permite calcular probabilidades con la densidad de la distribución normal.
Señala cuál es la dispersión de los datos en una distribución normal a uno, dos y tres sigmas o desviaciones estandar.
Regla que nos permite analizar como se distribuyen los datos en una distribución normal.
Analizamos la distribución de los datos sabiendo cuales son los datos que podemos encontrar a un, dos y tres sigma de
distancia.
Esto quiere decir que a una , a dos y a tres deviaciónes estandar.
Esto indica que la densidad de la probabilidad de encontrar datos en una

desviación estandar de la media dentro de cualquir distribución normal es
aproximadamente igual a 68% , de encontrarlo en dos desvicaciones estandar es
95% y de encontrarlo en tres es 99.7% .
Esto nos habla de como se estan distribuyendo los datos, podemos decir que sabemos que un evento ocurrira con cierta
probabilidad más o menos el intervalo de confianza.
Ahora podemos entender porque cuando se levanta una encuesta existe un grado de confiabilidad, y es justamente este
95% que te habla del grado de confiabilidad, el cual son las desviaciones estandar que estamos teniendo de las cuales
podemos concluir que las muestras que saquemos de la distribucion se encontraran en ese rango.
Se habla de más menos dado que puede ser más 1na desviaciones media, hacia la derecha y
menos 1na desviación media, hacia la izquierda. Mira el grafico
En este histograma podemos ver que a más menos una

desviación estandar encontramos el 68% de los datos,
luego más menos dos desviaciones estandar encontramos
el 95% de los datos y más menos tres desviaciones
estandar estamos encontrando el 99.7%.
https://www.youtube.com/watch?v=phY8Z9TXCY
menos más
Simulaciones de Montecarlo
Permite crear simulaciones para predecir el resultado de un problema.
Utilizan aleatoriedad para resolver un problema.

Permite convertir problemas determinísticos en problemas estocásticos. Calcular el area de un rectangulo, el número pi,
etc..
Es utilizado en un gran diversidad de áreas, desde ingienería hasta biología y derecho.
Simulación de Barajas
En esta simulación queremos saber la posibilidad de obtener un par de cartas al iniciar la partida.
Para eso tuvimos que crear una función que genera un mazo aleatorio a paritir de una baraja, tambien generada por una
función, sin repetición de cartas gracias al método sample .
import random
import collections
TIPOS = ['espada', 'corazon', 'rombo', 'trebol']

VALORES = ['as', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'jota', 'reina', 'rey']
def crear_baraja():
baraja = []
for tipo in TIPOS:
for valor in VALORES:
baraja.append( (tipo, valor) )
return baraja
def obtener_mazo(baraja, tamano_mazo):

mazo = random.sample(baraja, tamano_mazo)
return mazo
def main(tamano_mazo, intentos):

baraja = crear_baraja() # 52 tuplas/cartas
mazos = [] # Contiene listas con tuplas [ (),().. ],[ (),().. ],[ (),().. ].....
for _ in range(intentos):
mazo = obtener_mazo(baraja, tamano_mazo)
mazos.append(mazo)
pares = 0
for mazo in mazos:
valores = []
for carta in mazo:
valores.append(carta[1]) # El elemento 1 es el valor
counter = dict(collections.Counter(valores)) # La clase counter cuenta lo repetido de los elementos en la lista valores, al usar la
for val in counter.values(): # values ya que es un diccionario

if val == 2:
pares += 1
break # Paramos ejecuccion, ya que solo queremos saber si existe un solo par por mazo
probabilidad_par = pares / intentos

print(f'La probabilidad de obtener un par en un mazo de {tamano_mazo} cartas es {probabilidad_par}')
if __name__ == "__main__":
tamano_mazo = int(input('Tamano de mazo: '))
intentos = int(input('Intentos: '))
main(tamano_mazo, intentos)
Crecimiento exponencial! Be careful.
Cálculo de PI
Vamos a calcular PI con el método de montecarlo, el cual usa número aleatorios. Es sencillo, imagina que tienes un
cuadrado y dentro de este dibujas un circulo. La formula para calcular el area de circulo es π ⋅ r2 y la formula para calcular
el area de un cuadrado es (2 ⋅ r)2 o l2 su lado al cuadrado.
Nuestro procedimiento sera disparar agujas de forma aleatoria al cuadrado (pudiendo caer dentro del circulo o fuera de el,
o sea, en el cuadrado). Para calcular PI debemos dividir el area de ambas figuras y despejar π .

π ⋅ r 2
(2 ⋅ r)2
Y esto es igual a:
π ⋅ r 2 Agujas al interior del circulo
=
(2 ⋅ r) 2 Agujas totales
Ahora toca simplificar la parte derecha de la equación.
2 2
=
2 ⋅ r Agujas totales
2
=
4 ⋅ r Agujas totales
π Agujas al interior del circulo
=
4 Agujas totales
Los radios se van a su casa. Y queda finalmente la magnifica formula para calcular π .
4 ⋅ Agujas al interior del circulo
π=
Agujas totales
La pregunta del millon es, ¿Como sabemos que agujas estan dentro del circulo?
Muy facil, usando pitagoras.
Como sabemos las ubicaciones de las agujas podemos calcular si estas forman parte del
area de la circunferencia midiendo la distancia con x2 + y 2 , si la distancia desde el
origen hasta la aguja es menor o igual a 1 quiere decir que esta al interior de la
circunferencia. Si es mayor que 1 quiere decir que esta fuera de la circunferencia.
Comenzamos importando las librerias a usar.
import random
from math import sqrt
from estadisticas import desviacion_estandar, media
Esta función "lanza la agujas" y nos devuelve el valor de pi.
def lanzar_agujas(numero_de_agujas):
dentro_circulo = 0
for _ in range(numero_de_agujas):
x = random.random() * random.choice([ -1, 1 ]) # random() Genera un número entre 0 y 1 luego se multiplica por -1 o 1. Ex: (0.4 * -1
y = random.random() * random.choice([ -1, 1 ]) # y = ]0,1[ * -1 o 1
distancia_desde_centro = sqrt(x**2 + y**2) # Ahora obtenemos la distancia!
if distancia_desde_centro <= 1: # Comprobamos la condición

dentro_circulo += 1 # Si es así, agregar a la variable "dentro_circulo"
return (4 * dentro_circulo) / numero_de_agujas # Al finalizar el lanzamiento de las agujas retornamos el valor de pi

Esta función llamara x veces a la función lanzar_agujas y guardar lo que retorne para sacar medidas de tendencia central.
def estimacion(numero_de_agujas, numero_de_intentos):

estimados = []
estimacion_pi = lanzar_agujas(numero_de_agujas) # Llamaremos a la función anterior x veces
estimados.append(estimacion_pi) # Agregaremos el resultado de pi a la lista "estimados"
media_estimados = media(estimados) # Al finalizar la iteración sacaremos la media de los valores al interior de la lista "estimados"
sigma = desviacion_estandar(estimados) # Y su desviación media
print(f'Est={round(media_estimados,5)}, sigma={round(sigma, 5)}, agujas={numero_de_agujas}') # Imprimieremos la estimación de pi, su des
Función main que llama a las demás y incrementa el número de agujas por cada iteración
def estimar_pi(precision, numero_de_intentos, numero_de_agujas):

sigma = precision # Inicialisamos la variable sigma con valor precision
# Mientras la precision, o sea, cuantas desviaciones estandar queremos sea mayor a la precision partida en la medida de fiabilidad, ejec
while sigma >= precision / 3.00: # 1 para una desviacion estandar=68%, 2=1.96 para dos desviaciones=95% y 3 para el 100%
estimacion(numero_de_agujas, numero_de_intentos) # ... la estimacion
numero_de_agujas *= 2 # y al terminar la estimación, duplica el numero de agujas.
Definimos el entry point de nuestro codigo
if __name__ == '__main__':
estimar_pi(0.01, 1000, 1000)
Codigo completo:
import random
from math import sqrt
from estadisticas import desviacion_estandar, media
def lanzar_agujas(numero_de_agujas):
dentro_circulo = 0
for _ in range(numero_de_agujas):
x = random.random() * random.choice([ -1, 1 ]) # x = ]0,1[ * -1, 1
y = random.random() * random.choice([ -1, 1 ])
distancia_desde_centro = sqrt(x**2 + y**2)
if distancia_desde_centro <= 1:
dentro_circulo += 1
return (4 * dentro_circulo) / numero_de_agujas
def estimacion(numero_de_agujas, numero_de_intentos):

estimados = []
estimacion_pi = lanzar_agujas(numero_de_agujas)
estimados.append(estimacion_pi)
media_estimados = media(estimados)
sigma = desviacion_estandar(estimados)
print(f'Est={round(media_estimados,5)}, sigma={round(sigma, 5)}, agujas={numero_de_agujas}')
def estimar_pi(precision, numero_de_intentos, numero_de_agujas):

sigma = precision
while sigma >= precision / 3.00: # 1 para una desviacion estandar=68%, 2=1.96 para dos desviaciones=95% y 3 para el 100%
estimacion(numero_de_agujas, numero_de_intentos)
numero_de_agujas *= 2

if __name__ == '__main__':
estimar_pi(0.01, 1000, 1000)
Muestreo de intervalos de confianza

Muestreo
Hasta ahora hemos hecho muchas muestras, obteniendo un ejemplo y comparandolo con todos los ejemplos obtenidos se
le denomida como muestreo.
Es importante cuando no tenemos la capacidad computacional para calcular toda la población. Imagine que tenemos un
data set enorme y queremos calcularlo rapidamente con un muestro de la población.
Hay ocasiones en las que no tenemos acceso a toda la población que queremos explorar.
Uno de los grandes descubrimientos de la estadística es que las muestras aleatorias tienden a mostrar las mismas
propiedades que la población objetivo. Con esto podemos sacar conclusiones validas sin tener que explorar toda la
población.
El tipo de muestreo que hemos hecho hasta ahora es muestreo probabilistico .
Tipos de muestreo probabilistico

Existe el muestreo aleatorio, en el que existe la misma probabilidad de escojer entre cualquier miembro de una
población. El que hemos usado.
En un muestro estratificado tomamos en consideración las características de la población para partirla en subgrupos y
luego tomamos muestras de cada subgrupo. Esto es para no sesgar grupos de cada población.
Incrementa la probabilidad de que el muestreo sea representativo de la población.
Teorema del límite central

Es uno de los teoremas más importantes de la estadísitca. Ya que nos permite convertir cualquier distribución en una
distribución normal.
Establece que muestras aleatorias de cualquier distribución van a tener una disitribución normal.
Permite entender cualquier distribución como la distribución normal de su media y eso nos permite aplicar todo lo que
sabemos.
Sucede que si tomamos cualquier distribución y le tomamos una muestra y a esa muestra le sacamos su media la
distribución de sus medias tendera a una distribución normal y conforme aumentemos el tamaño de la muestra cada
vez tendera a ser más una distribución normal.
Mientras más muestras obtengamos, mayor será la similitud con la distribución normal.
Mientras la muestra sea de mayor tamaño, la desviación estandar será menor.
Del lado izquierdo una muestra binominial, o sea, con dos picos. Tiene una
media y una desviación estandar definida por σ .
Sucede en esta imagen que comenzamos a tomar muestras de tamaño n y

luego a sacar sus promedios x. Al cabo de varias muestras esto
comenzara a generar una distribución normal a partir de su media μ.
Ejemplo:
Imagina que hiciste una encuesta en tu colegio en la que solo preguntabas

la edad y altura. Sucede que al graficar te encuentras con algo inesperado,
Vale decir que las medias en ambas obtienes una distribución binomial ya que no tomaste en consideración los
distribuciones serán siempre las subgrupos dentro de la población niños y niñas, algo que no esperabas, en
mismas. su lugar esperabas una distribución normal. Pero como sabes estadistica,

La desviación estandar de la vas y usas el teorema del límite central. Tomas una muestra de 1/4 del total
σ
distribución normal es n
. de tu población y obtienes su media, luego tomas otro 1/4 y continuas
obteniendo su media, así sigues hasta que lo haces con toda la población.
O sea la desviación estandar de la
Al final graficaras estas medias de cada 1/4 juntas y obtendras una
distribución padre dividida en la raíz de
distribución normal!
la cantidad de elementos de la muestra.
Ten en cuentas que tus posibles concluciones a partir de la media sean
Ejemplo:
algo erradas ya que para este problema hubiera sido una mejoro opción un
Si cada muestra tenía 10 elementos muestreo estratificado, o sea, además de preguntas altura y edad, debiste
entonces sumas el total de muestas, en preguntar el genero.
el ejemplo 1/4 es 10. Entonces el total
de la población n es 40 . Ahora
supongamos que la desviación estandar
de la distribución padre es 2 . La
ejecucción de la formula sería la
2
siguiente 40
, lo que sería 0.31 aprox.
Si te fijas, se reducio notablemente el
tamaño de la desviación estandar.
Datos Experimentales
Es la aplicación del método científico.
Es necesario comenzar con una teoría o hipótesis sobre el resultado al que se quiere llegar.
Basado en la hipótesis se debe crear un experimento para validar o falsear la hipótesis.
Se valida o falsea una hipótesis midiendo la diferencia entre las mediciones experimentales y aquellas mediciones
predichas por la hipótesis.
Un ejemplo sería la teoria de la relatividad, en su momento no se pudo comprobar pero en estos días se ha podido
parcialmente comprobar esta teoría.
Regresión Lineal
Permite aproximar una función a un conjunto de datos obtenidos de manera experimental.
No necesariamente permite aproximar funciones linales, sino que sus variantes permiten aproximar cualquier función
polinómica.
Conclusiones
Aprendimos:
Como funciona la programación dinamica y como pueden optimizar nuestros programas.
Como los computadores pueden resolver problemas determinísticos y estocásticos.
Como usar random de forma extensiva.
Como generar simulaciones computaciones para responder preguntas del mundo real.
Como la inferencia estadística nos permite tener confianza de que nuestras simulaciones arrijan resultados válidos.

Notas Curso de Estadistica Computacional

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Notas Curso de Estadistica Computacional

Cargado por

Copyright:

Formatos disponibles

Curso de estadistica computacional

Autor Pablo Pérez

Fecha de Creación Jan 15, 2021 608 PM

Introducción a la Programación Dinámica

Introducción a la Programación Dinámica

No relacionada con su nombre

Curso de estadistica computacional 1

return fibonacci_recursivo(n-1) + fibonacci_recursivo(n-2)

def fibonacci_dinamico(n, memory={}):

Curso de estadistica computacional 2

inp = int(input("N = "))

Ejemplo, Movimiento Browniano y particulas de humo.

Estos movimientos de particulas de humo se crean dando a la particula movimientos

Pero no solo podemos simular el movimiento de particulas tambien el de galaxias y planetas.

Curso de estadistica computacional 3

Como sabemos tampoco los caminos aleatorios se limitan al campo de la física.

Esta estructura fue hecha por el artista Antony Gormley, pero no

Curso de estadistica computacional 4

from bokeh.plotting import figure, show

from borracho import BorrachoOlimpico

def caminata(campo, borracho, pasos):

def simular_caminata(pasos, numero_de_intentos, tipo_de_borracho):

def graficar(x, y):

def main(distancias_de_caminata, numero_de_intentos, tipo_de_borracho):

Curso de estadistica computacional 5

print(f'{tipo_de_borracho.__name__} caminata aleatoria de {pasos}')

main(distancias_de_caminata, numero_de_intentos, BorrachoOlimpico)

Introducción a la programación Estocaśtica

Ejemplos de un programa determinista: El SO de tu computador.

Una probabilidad de 0 significa que un suceso jamás sucedera.

Una probabilidad de 1 significa que un suceso está garantizado de suceder en el futuro.

La probabilidad de que un evento suceda y de que no suceda siempre es 1 .

Ley del complemento

La probabilidad de que ocurra A y la probabilidad de que no ocurra A es igual a 1

Curso de estadistica computacional 6

Probabilidad de que un evento A y otro envento B sucedan.

Ponte en el siguiente caso:

Dependientes uno de otro

Probabilidad de que A y B sucedan si son dependientes del otro.

P (A o B) = P (A) + P (B)

P (A o B) = P (A) + P (B) − P (A y b)

P (A o B) = 0.5 + 1 − 0.5

Ley de los Grandes Números

Curso de estadistica computacional 7

def main(numero_de_tiros, numero_de_intentos):

probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos

#print(f'Probabilidad de no obtener por lo menos un 1 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1} ')

promedio = sum(promedio) / len(promedio)

print(f'Promedio de por lo menos no obtener 1 en {numero_de_intentos} tiros = {promedio}')

¿Qué pasa cuando no sabemos las probabilidades de los eventos simples?

"El principio guía de la Inferencia Estadística

Curso de estadistica computacional 8

La probabilidad P de que conforme la media X de la población n se acerque a la

Falacia del Apostador

💡 ESTO ES FALSO, CADA EVENTO ES INDEPENDIENTE

Lo que si sucede es la regresión a la media!

Uno de los ejemplos más claros es la ruleta de montecarlo.

En el casino de montecarlo en 1943 sucedio un evento extremo, sucedio

La probabilidad de que surjan 32 negros despues de 32 rojos es bajisima.

Medida d etendencia central

Comúnmente es conocida como el promedio

xi Significa que tenemos un arreglo de esquices que comienzan en el indice i = 1

Curso de estadistica computacional 9

print(f'{tipo_de_borracho.name} caminata aleatoria de {pasos}')

distancia_desde_centro = sqrt(x2 + y2) # Ahora obtenemos la distancia!

distancia_desde_centro = sqrt(x2 + y2)