Teorema del Límite Central

RETO : DADOS
Como se sabe los lanzamientos de datos tienen una distribución uniforme, debido a que cada número tiene las mismas posibilidades que salir que los otros 5 => (1/6). Entonces lo que hice fue crear un script donde se realiza una cantidad de lanzamientos de dados y se obtenga la cantidad de veces que salio cada número, luego seleccionar muestras de 10 lanzamientos y hallar su media.
Con 1000 lanzamientos:

Con 2000 lanzamientos:

Es increíble el poder de las matemáticas 😄

Codigo:

import random
import collections
from bokeh.plotting import figure,show
from bokeh.layouts import row

def population(number_of_throw):
    throws =[]
    throws_sample=[]
    sample_mean =[] #media de todas las muestas 
    for _ in range(number_of_throw):
        dice = random.choice([1,2,3,4,5,6])
        throws.append(dice)
        throws_sample.append(dice)
        if( _ %10==0): #promediamos la muestra de los 10 lanzamientos
            sample = sum(throws_sample)/len(throws_sample)
            sample_mean.append(sample)
            throws_sample=[] 

    throws=sorted(throws)
    sample_mean=sorted(sample_mean)
    sample_mean=dict(collections.Counter(sample_mean))
    throws=dict(collections.Counter(throws))
    return (throws, sample_mean)

def graph(values,title):
    
    number_of_dice=list(values.keys())
    values_of_throws=list(values.values())
    p = figure(title=title, x_axis_label='Number of Dice', y_axis_label='Quantity')
    p.vbar(x=number_of_dice,top=values_of_throws,width=0.5, color="#CAB2D6")
    return p

def main():
    quantity=int(input("Cantidad de lanzamientos: "))
    values_throws,values_sample = population(quantity) #tengo x lanzamientos de dados que me da una un gráfico uniforme
    # gráfico uniforme por que cada número del dado tiene la misma posibilidad de salir (1/6)
    show(row(graph(values_throws,"Dice Throws"),graph(values_sample,"Media Sample")))


if __name__ == "__main__":
    main()```

para reforzar
https://youtu.be/z2V1LX8tK7U

Un video muy didactico!!!
https://www.youtube.com/watch?v=YAlJCEDH2uY

Hola,

Les comparto mi solución al reto:

import random
import collections
from estadisticas import desviacion_estandar, media

from bokeh.plotting import figure, output_file, show

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        dado_1 = random.choice([1, 2, 3, 4, 5, 6])
        dado_2 = random.choice([1, 2, 3, 4, 5, 6])
        tiro = dado_1 + dado_2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def graficar(x, y):

    plot = figure(title="Distribucion Normal")
    plot.vbar(x, top=y, width=0.5, color="#CAB2D6")
    output_file("vertical_bar.html")
    show(plot)

def estimacion(numero_de_tiros):

    estimados = tirar_dado(numero_de_tiros)

    media_estimados = media(estimados)
    sigma = desviacion_estandar(estimados)

    counter = dict(collections.Counter(estimados))

    graficar(list(counter.keys()), list(counter.values()))

    return (media_estimados, sigma)

def main(numero_de_tiros):

    media, sigma = estimacion(numero_de_tiros)
    print(f'Est = {round(media, 5)}, sigma = {round(sigma, 5)}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Diga la cantidad de tiros con los que quiere iniciar: '))
    main(numero_de_tiros)

Como era de esperar, el valor mas repetido es el 7 como se muestra en la siguiente gráfica:

Con 400000 lanzamientos se tiene que:

Media = 6.99551, sigma = 2.41618

https://github.com/karlbehrensg/programacion-dinamica-y-estocastica
Teorema del Límite Central

El teorema del límite central es uno de los teoremas más importantes de la estadística. Establece que muestras aleatorias de cualquier distribución van a tener una distribución normal. Esto permite entender cualquier distribución como la distribución normal de sus medias y eso nos permite aplicar todo lo que sabemos de distribuciones normales.

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 estándar será menor.

por si alguien más quiere jugar con el “programita” mostrado en clase:

http://195.134.76.37/applets/AppletCentralLimit/Appl_CentralLimit2.html

😱. Este curso me enseño el gran PODER y UTILIDAD de la estadística y es increíble usarla en la programación

Aplicación del teorema del límite central para un lanzamiento de 2 dados de 10 veces, en repeticiones de 100,1000,10000 y 100000.

import random
from estadisticas import desviacion_estandar, media
from bokeh.plotting import figure, show
import collections

#calcula la media de la suma de dos datos en x lanzamientos con y intentos
def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro1 = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro1+tiro2)

    return secuencia_de_tiros

def main(numero_de_tiros, tamano_muestra):

    X=[]
    for _ in range(tamano_muestra):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        X.append(media(secuencia_de_tiros)) #promedia la suma de los tiros y los guarda en una lista

    counter = dict(collections.Counter(X)) #agrupa y cuenta las repeticiones de los valores promedios de la suma
    x = list(counter.keys())
    y = list(counter.values())
    graficar(x,y)

def graficar(x, y):
    grafica = figure(title='normal_distribution',x_axis_label='Avg', y_axis_label='n')
    grafica.vbar(x, top= y, width=0.08, color='yellowgreen')
    show(grafica)

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    tamano_muestra = int(input('Ingresa es el tamaño de la muestra: '))
    main(numero_de_tiros, tamano_muestra)

al grano, espero ayude

https://www.youtube.com/watch?v=46DgBP9VwtE

Si quieren reforzar los conocimientos de esta clase, les dejo este video de Khan Academy
https://www.youtube.com/watch?v=EC1bTDBz46k

https://www.youtube.com/watch?v=EC1bTDBz46k

Aquí donde se podría reforzar más el tema

Teorema del limite central
Nos permite convertir una distribución en una distribución normal, la cual esta ampliamente estudiada y bien definida.
El procedimiento consiste en coger la población y dividirla en una cantidad de muestras. Al realizar la distribución de las medias de nuestras muestras esta se acercará progresivamente a una distribución normal.
Nota:
Mientras más grandes nuestras muestras (samples) más cerca estaremos de una distribución normal pero nuestros datos se reducen (si tenemos 1000 datos, generamos muestras de 5, la nueva distribución tendrá 200 datos, pero si generamos muestras de 10, la distribución tendrá 100 datos)

Explicación del TLC con dados
Como sabemos el lanzamiento de un dado tiene una distribución uniforme (cada valor tiene la misma probabilidad de ocurrir).
Si agrupamos estos lanzamientos en samples de 10, por ejemplo, y obtenemos la media ya no tendremos una distribución uniforme; la distribución se normaliza, es decir que es poco probable que la media este en los extremos: 1 o 10 puesto que para eso deberían haber salido muchos 1 o muchos 10. La mayor probabilidad estará entonces en el medio: 5 o 6 (puesto de los 1 se neutralizan con los 10), obtenemos entonces una distribución normal.

F señor David Aroesti no explico muy bien

Un ejemplo Actual sobre como aplicar el teorema del limite central, observar el comportamiento del dolar, esta es mi pagina favorita https://mx.investing.com/currencies/usd-mxn, puedes redimencionar la grafica en periodos de tiempo y a la vez reducir los datos (muestras).

“Es bellisimo”.jpg

Mi código

Si alguna vez sienten que no son normal recuerden que el promedio es normal.

Este es mi código del reto:

import random
from esatdistica import desviacion_estandar, media
import collections
from bokeh.plotting import figure, show

def tirar_dado(numero_de_tiros):

    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro_1 = random.choice([1,2,3,4,5,6])
        tiro_2 = random.choice([1,2,3,4,5,6])
        tiro = tiro_1 + tiro_2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def graficar(x, y):
    grafica = figure(title='Distribucion')
    grafica.vbar(x, top=y, width=0.5)

    show(grafica)


def main(numero_de_intentos):

    secuencia_de_tiros = tirar_dado(numero_de_intentos)

    media_tiros = media(secuencia_de_tiros)
    sigma = desviacion_estandar(secuencia_de_tiros)

    counter = dict(collections.Counter(secuencia_de_tiros))

    x = list(counter.keys())
    y = list(counter.values())

    graficar(x,y)


if __name__ == '__main__':

    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_intentos)

Se logra observar que el teorema se cumple.
Aqui hay 50 tiros:
(

Y aqui hay 100.000 tiros:
(

Teorema de límite central.

por si a alguien le sirve 😄
el teorema del limite central, explicado

• Es uno de los teoremas más importantes de la estadística. Establece que muestras aleatorias de cualquier distribución van a tener una distribución normal.

• Permite entender cualquier distribución como la distribución normal de sus medias y eso nos permite aplicar todo lo que sabemos de distribuciones normales.

• La ventaja de de esto es que conocemos todo sobre distribuciones normales, y compensa lo poco que sabemos de muchas otras distribuciones extrañas 😆.

a mi no me cierra por que si tenes una caja con una meda de dos y le agregas otra con esa media. por que seria 4. seguiría siendo dos

Estos 2 videos servirán para reforzar el tema:
1

2

Con esto no he probado el Teorema del Limite Central, lo que si puedo haber probado es que todo evento aleatorio tiene una distribucion normal.
Manana intentare con el Teorema de Limite Central
Mi ejemplo con los dados

• 1 dado / 100 ensayos
  
  
• 2 dados / 1000 ensayos
  
  
• 3 dados / 10000 ensayos
  
  
• 4 dados / 100000 ensayos
  
  
• 8 dados / 1000000 ensayos
  
  
  Codigo
• Dado

import random

class Dado:

    def __init__(self):
        self

    def tirar_dado(self, cantidad_de_dados):
        secuencia_de_tiros = []
        for _ in range(cantidad_de_dados):
            secuencia_de_tiros.append(random.randint(1,6))
        return secuencia_de_tiros

• Probabilidades

from dado import Dado
from estadisticas import desviacion_estandar, media
from bokeh.plotting import figure, show, output_file, ColumnDataSource
from bokeh.transform import factor_cmap
from bokeh.palettes import viridis
import collections

def tirar_dado(cantidad_de_dados, numero_de_tiros):
    secuencia_de_tiros = []
    dado = Dado()

    for _ in range(numero_de_tiros):
        tiros = dado.tirar_dado(cantidad_de_dados)
        secuencia_de_tiros.append(tiros)

    return secuencia_de_tiros

def graficar(x, y):

    # str1 = []
    
    # for e in x:
    #     string = str(e)
    #     str1.append(string)

    # source = ColumnDataSource(data=dict(x=x, y=y))

    grafica = figure(
        title='Normal Distribution - Dices',
        plot_width=700,
        plot_height=700,
        x_axis_label='Results',
        y_axis_label='Repetitions',
        # x_range=str1
    )
    grafica.vbar(
        x = x,
        # x='str1',
        top= y,
        width=0.5,
        color='orange',
        # fill_color=factor_cmap(
        #     'str1',
        #     palette=viridis(50),
        #     factors=str1
        #     ),
        # legend='x',
        # source=source
        )
    show(grafica)

def main(cantidad_de_dados, numero_de_tiros, numero_de_simulaciones, numero_de_probabilidad):
    resultado = []

    for _ in range(numero_de_simulaciones):
        secuencia_de_tiros = tirar_dado(cantidad_de_dados, numero_de_tiros)
        resultado.append(secuencia_de_tiros)

    # print(resultado)

    resultado_suma = []
    suma_de_dados_por_tiro = 0
    lista_normal = []

    for i in resultado:
        lista_apoyo = []
        for ii in i:
            for iii in ii:
                suma_de_dados_por_tiro += iii
            lista_apoyo.append(suma_de_dados_por_tiro)
            lista_normal.append(suma_de_dados_por_tiro)
            suma_de_dados_por_tiro = 0
        resultado_suma.append(lista_apoyo)

    # print('\n')
    # print(resultado_suma)
    # print('\n')
    # print(lista_normal)

    print('\n')
    print(f"{'-'*23}PROBABILIDADES{'-'*23}")

    tiros_con = 0
    for i in resultado_suma:
        if numero_de_probabilidad in i:
            tiros_con += 1

    # print(tiros_con)

    probabilidad_tiros_con = tiros_con / numero_de_simulaciones
    probabilidad_tiros_sin = 1 - probabilidad_tiros_con

    print(f'Probabilidad de obtener por lo menos un {numero_de_probabilidad} en {numero_de_tiros} tiros = {probabilidad_tiros_con}')
    print(f'Probabilidad de no obtener por lo menos un {numero_de_probabilidad} en {numero_de_tiros} tiros = {probabilidad_tiros_sin}')

    # Preparamos el diccionario para tener los datos de las simulaciones
    counter = dict(collections.Counter(lista_normal)) #agrupa y cuenta las repeticiones de los valores promedios de la suma
    x = list(counter.keys())
    y = list(counter.values())
    graficar(x,y)
    # print(counter)

    return resultado, resultado_suma


if __name__ == '__main__':
    cantidad_de_dados = int(input('Indicar con cuantos dados quieres jugar: '))
    numero_de_tiros = int(input('Por favor indicame cuantos tiros deseas hacer en cada simulacion: '))
    numero_de_simulaciones = int(input('Ahora dime cuantas simulaciones deseas hacer: '))
    numero_de_probabilidad = int(input('Finalemente dime de que numero quieres hallar la probabilidad: '))

    main(cantidad_de_dados, numero_de_tiros, numero_de_simulaciones, numero_de_probabilidad)

    # resultado, resultado_suma = main(cantidad_de_dados, numero_de_tiros, numero_de_simulaciones, numero_de_probabilidad)
    
    # print(f"{'-'*25}RESULTADOS{'-'*25}")
    # print(resultado)
    # print(f"{'-'*28}SUMA{'-'*28}")
    # print(resultado_suma)
    # print('-'*60)

Teorema del Limite Central

La distribución de las medias de las muestras(X) se acerca a una distribución normal cuando el tamaño de la muestra se hace grande, ademas la media de esta distribución es la misma que el de la población.

El siguiente vídeo me ayudo a entenderlo

👉https://www.youtube.com/watch?v=xZmFqLHIFJk👈

Me parece que lo adecuado sería decir que, la medias de cualquier distribución -que sean las mismas distribuciones-, por el Teorema del Límite Central - TLC seguirán una Distribución Normal.

Por ejemplo, si tuviera 30 Distribuciones Exponenciales… si éstas se agregan, seguirán una Distribución Erlang, pero si se toma la media de cada una de éstas 30 Distribuciones Exponenciales, dichas medias seguirán una Distribución Normal por el TLC.

Creo que decir que cualquier distribución se puede convertir en Distribución Normal no es el fin del TLC.

A esto también se refiere el muestreo, cada grupo en una población puede tener sus propias características o distribuciones (exponencial, beta, uniforme o de otra índole) y si se juntan omitiendo este aspecto -alumnos que programan en platzi- puede salir sesgado el TLC por mezclar diferentes distribuciones.

Realmente como se menciona en el video este tema es muy amplio… nunca pares de aprende!

• Es uno de los teoremas más importantes de la estadística
• Establece que muestras aleatorias de cualquier distribución van a tener una distribución normal
• Permite entender cualquier distribución como la distribución normal de sus medias y eso nos permite aplicar todo lo que sabemos de distribuciones normales

este es mi codigo amigos, aqui puedes indicarle cuantos dados lanzara en un input, espero les sirva

import random 
from bokeh.plotting import figure, show
import collections

def throw_dice(n_dados):
    # esta funcion solo escoge un numero aleatorio entre 1 y 6
    # despues dependiendo de el input(n_dados)
    # regresa en un array la los tiros que hizo
    secuencia_dados = []
    for _ in range(n_dados):
        n_a = random.choice([1,2,3,4,5,6])
        secuencia_dados.append(n_a)

    return secuencia_dados


def graficar(xs,ys):
    F = figure()
    F.vbar(xs, top=ys, width=0.5)
    show(F)

def main(n_dados, n_intentos):
    probabilidades=[]
    for y in range(n_intentos):
        #tiramos un dado las veces que le indicamos
        throws = throw_dice(n_dados)

        # y luego las sumamos para asi tener mas variables 
        # en nuestra poblacion. :D
        n_a = sum(throws)
        probabilidades.append(n_a)
    # la funcion collections.Counter "CUENTA"
    # la cantidad que tienes de cada valor 
    # en tu array y los devulve en un diccionario
    coll = dict(collections.Counter(probabilidades))
    # print(coll)
    xs = list(coll.keys())
    ys = list(coll.values())

    graficar(xs, ys)



if __name__ == '__main__':
    n_dados = int(input('''numero de dados'''))
    n_intentos = int(input('''numero de intento'''))
    main(n_dados,n_intentos)

2 dados 1000 intentos

9 dados 1000 intentos

100 dados 1000 intentos

Aquí dejo el resultado del reto, hice un pequeño programa que calcula la media del lanzamiento de n dados (uno puede escoger cuantos dados lanzar), guarda el resultado de m lanzamientos y grafica su distribución.

El código:

import random
import collections
from bokeh.plotting import figure, show


# calculate the mean of rolling n dice
def roll_the_dice(number_of_dice):

    rollings = []
    for _ in range(number_of_dice):
        rolling = random.choice([1, 2, 3, 4, 5, 6])
        rollings.append(rolling)

    return sum(rollings) / len(rollings)


def simulate_dice_rollings(number_of_dice, number_of_rollings):
    sequence_of_results = []
    for _ in range(number_of_rollings):
        result = roll_the_dice(number_of_dice)
        sequence_of_results.append(result)

    return sequence_of_results


# plot the distribution of the mean roll of n dice
def plot_histogram(results, number_of_dice):
    counter = dict(collections.Counter(results))
    x = list(counter.keys())
    y = list(counter.values())
    plot = figure(title=f'Distribution of the mean roll of {number_of_dice} dice',
                  x_axis_label='Mean',
                  y_axis_label='Frequency')
    plot.vbar(x=x, top=y, width=0.9/number_of_dice)
    show(plot)
    

if __name__ == '__main__':
    number_of_dice = int(input('How many dice do you wnat to roll?: '))
    number_of_rollings = int(input('How many times do you want to roll the dice?: '))
    results = simulate_dice_rollings(number_of_dice, number_of_rollings)
    plot_histogram(results, number_of_dice)

Las siguientes son las gráficas que obtuve para 1, 2, 5 y 100 dados con 10000 lanzamientos

Dejo como extra la gráfica del lanzamiento de 500 dados lanzados 1 millón de veces:

Mis resultados:

This blew my mind!

que cosas tan loca

Entendido y a poner en práctica

Mi aportación es en el ámbito matemático.

Matemáticamente hablando, una muestra aleatoria de tamaño n X_1, X_2,…, X_n se define como una colección de variables aleatorias independientes e idénticamente distribuidas, ahora bien, si consideramos que tienen esperanza y varianza finita (la esperanza es la media), al ser idénticamente distribuidas tendremos:

mu=E(X_i) (la esperanza de X_i) para 1<= i <= n
sigma^2 =Var(X_i)

Por otro lado, las respectivas operaciones (esperanza y varianza) cumplen (entre otras) las siguientes propiedades:
Esperanza (linealidad):
Para cuáles sean X e Y variables aleatorias y r un escalar
E(X+rY)=E(X)+rE(Y)
Varianza:
Var(rX)=r^2 Var(X)
si X e Y son independientes, entonces
Var(X+Y)=Var(X)+Var(Y)

Con esto en mente y usando el estimadro X barra que denotaremos por X’=(X_1+…+x_n)/n
tendremos lo siguiente
E(X’)=E((X_1+…+X_n)/n)=(1/n)(E(X_1)+…+E(X_n))=
(1/n)n(mu)=mu (no cambia la esperanza, a esto se le llama insesgamiento)

Para la varianza tendremos
Var(X’)=(1/n^2)(Var(X_1)+…+Var(X_n))=(n/n^2)Sigma^2=
sigma^2/n, tomando el límite cuando n va a infinito tendremos que la varianza tiende a cero, por eso a más grande es la muestra más pequeña es la varianza de X barra.

Referencias:
Curso intermedio de probabilidad, Luis Rincón, Prensa de ciencias, facultad de ciencias UNAM
Una introducción a la estadística inferencial, mismo autor y editorial.
http
😕/lya. fciencias.
unam.
mx/lars/
En esta liga pueden acceder a toda su bibliografía y recursos. Saludos.

Este video me ayudó mucho a complementar la clase 😃

Aqui dejo la distribucion uniforme de lanzar los dados 100,000 veces

y la distribucion normal
con las 10,000 muestras con 100 intentos en cada una

Cada linea horizontal marca hasta un multiplo de sigma hasta 5 sigmas
y la linea vertical de la media

import random
import math
import matplotlib.pyplot as plt
from statistics import mode
import numpy as np

class Dado:
    def __init__(self):
        self.valor = 0

    def tirar(self):
        self.valor = random.randint(1,6)

    def getValor(self):
        return self.valor

dado = Dado()
numero_de_tiros = 100000
resultados = []
for _ in range(numero_de_tiros):
    dado.tirar()
    resultados.append(dado.getValor())

print(f'Numero 1 salió: {resultados.count(1)} veces')
print(f'Numero 2 salió: {resultados.count(2)} veces')
print(f'Numero 3 salió: {resultados.count(3)} veces')
print(f'Numero 4 salió: {resultados.count(4)} veces')
print(f'Numero 5 salió: {resultados.count(5)} veces')
print(f'Numero 6 salió: {resultados.count(6)} veces')

plt.figure().patch.set_facecolor('xkcd:white')
plt.hist(resultados, bins=np.arange(min(resultados), max(resultados)+1,0.5))
plt.show()

tamaño_de_muestras = 10000
tiros_por_muestra = 100
medias_de_resultados = []

for _ in range(tamaño_de_muestras):
    resultados = []
    for _ in range(tiros_por_muestra):
        dado.tirar()
        resultados.append(dado.getValor())
    medias_de_resultados.append(sum(resultados)/len(resultados))

media = sum(medias_de_resultados)/len(medias_de_resultados)
moda = mode(medias_de_resultados)
varianza = sum([(x - media)**2 for x in medias_de_resultados])/len(medias_de_resultados)
sigma = math.sqrt(varianza)

print(f"La media de los resultados es: {media}")
print(f"La desviación estándar es: {sigma}")

y = medias_de_resultados.count(mode(medias_de_resultados))

bins = np.arange(min(medias_de_resultados), max(medias_de_resultados), 0.01)

plt.figure().patch.set_facecolor('xkcd:white')
plt.plot([media-sigma*5,media+sigma*5], [y+10*5, y+10*5], 'k', linewidth=5, )
plt.plot([media-sigma*4,media+sigma*4], [y+10*4, y+10*4], 'y', linewidth=5, )
plt.plot([media-sigma*3,media+sigma*3], [y+10*3, y+10*3], 'b', linewidth=5, )
plt.plot([media-sigma*2,media+sigma*2], [y+10*2, y+10*2], 'g', linewidth=5, )
plt.plot([media-sigma,media+sigma], [y+10*1,y+10*1], 'r', linewidth=5, )
plt.plot([media,media], [0, y], 'r', )
plt.hist(medias_de_resultados, bins=bins)
plt.show()

MIL GRACIAS PLATZI, AL FIN ESTOY ENTENDIENDO LAS ESTADISTICAS !!! HABIA ESTUDIADO MUCHO EN LA UNIVERSIDAD PERO AQUI LA HE ENTENDIDO !!!

Creo que cuando dices binomial, en realidad quieres decir bimodal

Hola amigos, les dejó una pieza de contenido para reforzar.

https://www.youtube.com/watch?v=46DgBP9VwtE&ab_channel=Estadísticaútil

El Teorema del límite central, es super importante para el humano.

Las demás distribuciones, no son muy manejables para los humanos por el momento.

Tenemos que tener en cuenta, que nuestras distribuciones normales, se toman de las medias de las muestras, lo divertido es que entre más mejor.

Lo que tenemos que hacer para comprobar que nuestras medias logren ser distribuciones normales, es tomar los resultados de varias muestras, con varias me refiero a mínimo 70 xD o las que más se puedan.

Las distribuciones de Poisson, que tienen una cola larga.

Se conoce como x hat a la media de una muestra.

Una muestra Binomial, significa que tiene dos picos.

Mientras la muestra sea de mayor tamaño, la desviación estándar será menor.

Las medias tienden a ser una distribución normal.

Mientras más grandes sean nuestras muestras, tengan un crecimiento, más normal serán, por lo que llegamos a tener una distribución muy fácil de analizar.

Lo que hacemos es tomar X distribución, luego tomamos de esta una muestra, a la cuál sacamos varias medias, la distribución de las medias que obtengamos va a tender a ser normal y conforme nosotros aumentemos el tamaño de la muestra. Cada vez generamos una distribución más y más normal.

El teorema del límite central, nos permite convertir cualquier distribución en una distribución normal.

El teorema del límite central, es uno de los más importantes de todas las matemáticas.

Reto de dados cumplido!!!

Acá dejo mi código para cualquier cantidad de dados:

• Ingresas la cantidad de dados que deseas lanzar
• Ingresas la cantidad de cada muestra (cantidad de numeros aleatorios que deseas por muestra)
• Ingresas cuantas muestras deseas sacar

import random
import collections
import numpy as np
import matplotlib.pyplot as plt

def throw_dice(dice_numbers, sample_size):
    throws_sequence = []
    for _ in range(sample_size):
        number_geted = 0
        for _ in range(dice_numbers):
            number_geted += random.choice([1, 2, 3, 4, 5, 6])
        throws_sequence.append(number_geted)
    
    return throws_sequence


def plot_frequency_diagram(means, unique_means):
    unique_means = sorted(unique_means)

    plt.hist(x=means, bins=unique_means)
    plt.title('Frequency Diagram of the Means')
    plt.xlabel('Means')
    plt.ylabel('Frequencies')

    plt.show()


def main(dice_numbers, sample_size, number_of_samples):
    sample_means = []
    for _ in range(number_of_samples):
        throws_sequence = throw_dice(dice_numbers, sample_size)
        sample_means.append(round(np.mean(throws_sequence), 2))

    counter = dict(collections.Counter(sample_means))

    plot_frequency_diagram(sample_means, list(counter.keys()))

    mu = np.mean(sample_means)
    sigma = np.std(throws_sequence)

    print(f'Mean: {round(mu, 4)}')
    print(f'Standar Deviation: {round(sigma, 4)}')


if __name__ == '__main__':
    dice_numbers = int(input('Número de dados: '))
    sample_size = int(input('Tamaño de la muestra: '))
    number_of_samples = int(input('Número de muestras: '))

    main(dice_numbers, sample_size, number_of_samples)

En este caso use 2 dados, con 200000 muestras de 20 números por muestra.

def lanzar_dado():
  return random.randint(1, 6)

n_dados = 10
n_lanzamientos = 5000

resultados = []

for i in range(n_lanzamientos):
  suma_dados = 0
  for dado in range(n_dados):
    suma_dados += lanzar_dado()
  resultados.append(suma_dados/n_dados)

resultados = np.array(resultados)
items, freq = np.unique(resultados, return_counts=True)

plt.bar(items, height=freq)
plt.show()

comparto mis resultados sobre el reto

El teorema del límite central: las medias de muestras grandes y aleatorias son aproximadamente normales

que interesante

que padre tema

sample = muestra

Para tener una referencia del ‘tamaño’ de la variabilidad respecto a la media, lo que se debe utilizar es el coeficiente de variación, que permite relativizar la referencia:

https://es.wikipedia.org/wiki/Coeficiente_de_variación

6:02 Se estaba derritiendo el profe JAJA

Lunes 12:12 a.m. wuuu

Reto

# -*- coding: utf-8 -*-
"""
Created on Sun May 31 14:39:15 2020

@author: Daniel Galvis
"""

import random
import collections
from bokeh.plotting import figure,show

def tirar_dados(numero_de_tiros):
    secuencia_de_tiros=[]
    for i in range(numero_de_tiros):
        tiro = random.choice([1,2,3,4,5,6])
        tiro2 = random.choice([1,2,3,4,5,6])
        secuencia_de_tiros.append(tiro+tiro2)
    
    return secuencia_de_tiros

def graficar(x,y):
    p=figure(plot_height=1000, plot_width=600,title = "Histograma de los dados", x_axis_label='Suma de los dados', y_axis_label='Ocurrencias')
    p.vbar(x=x,top=y,width=1)
    show(p)
    
       
    
def main(numero_de_tiros,numero_de_intentos,numero):
    tiros=[]
    tiros2=[]
    x=[]
    y=[]
    for i in range(numero_de_intentos):
        secuencia_de_tiros=tirar_dados(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    for j in tiros:
        tiros2.append(j[0])
    
    histograma=dict(collections.Counter(tiros2))
    for key,value in histograma.items():
        x.append(key)
        y.append(value)
    
    graficar(x,y)
    # NOT IN Y IN IMPORTANTE DE LA CLASE
    tiros_con_1=0
    for j in tiros:
        if numero in j:
            tiros_con_1+=1
    
    probabiidad_tiros_con_1=tiros_con_1/numero_de_intentos        
    print(f'Probabilidad de obtener por lo menos un {numero} en {numero_de_tiros} tiros {probabiidad_tiros_con_1}')
    
if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros de los dos dados: '))
    numero_de_intentos=int(input('Cuantas veces correra el programa: '))
    numero=int(input('La probabilidad que salga el numero: '))
    main(numero_de_tiros,numero_de_intentos,numero)```

mi aporte en el desafío, me costo mucho de estudiar el código de ostrujillop, pero lo logre.

![](

![](

![](

Tomé la solución que varios postearon y le añadí labels (etiquetas) a las barras. Los labels son los valores de y. Comparto la gráfica, el código y las fuentes.

Y aquí está el código (solo pongo comentarios en lo que añadí de las respuestas de otros).

import random
import collections
from bokeh.plotting import figure, show
# Además de lo visto en clase tuve que importar lo siguiente:
from bokeh.models import ColumnDataSource, Label, LabelSet, FixedTicker

def tirar_dados(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro1 = random.choice([1,2,3,4,5,6])
        tiro2 = random.choice([1,2,3,4,5,6])
        secuencia_de_tiros.append(tiro1 + tiro2)

    return secuencia_de_tiros

if __name__ == "__main__":
    numero_de_tiros = 10000
    secuencia_de_tiros = tirar_dados(numero_de_tiros)
    
    counter = dict(collections.Counter(secuencia_de_tiros))

    x = list(counter.keys())
    y = list(counter.values())
    
    # Las etiquetas solo pueden editarse usando un tipo "ColumnDataSource" que básicamente
    # es una estructura de datos que surge de dictionary. En el "ColumnDataSource" se listan
    # las especificaciones que no están incluidas por default.
    source = ColumnDataSource(dict(x = x, y = y))

    grafica = figure(title='Distribución de la suma de los resultados de lanzar dos dados',
        x_axis_label='Resultados',
        y_axis_label='Número de incidencias')

    # Si ya creaste un "ColumnDataSource" también se puede usar para crear gráficas.
    grafica.vbar(source=source,x='x',top='y',width=0.75)

    # Esto solo es para que la escala en el eje de la x sea igual que los valores de los
    # resultados de los lanzamientos de dados.
    grafica.xaxis.ticker = FixedTicker(ticks=x)

    # Aquí es donde se especifica el label haciendo referencia al "ColumnDataSource".
    labels = LabelSet(
        x='x',
        y='y',
        text='y',
        level='glyph',
        source=source,
        text_align='center')
    
    # Aquí añadimos los labels a la gráfica.
    grafica.add_layout(labels)

    show(grafica)```

Y aquí están las fuentes:
[Stackoverflow: hos to add data labels](https://stackoverflow.com/questions/39401481/how-to-add-data-labels-to-a-bar-chart-in-bokeh)
[Para ajustar el eje x](https://docs.bokeh.org/en/latest/docs/reference/models/axes.html)
[Sobre como configurar LabelSet](https://docs.bokeh.org/en/latest/docs/reference/models/annotations.html)

Que importante es tratar de convertir cualquier distribución a distribución normal para tener mayor seguridad que nuestro estudio de lapoblación da los resultados esperados.

Mas o menos entiendo, investigare mas al respecto.

import random
from bokeh.plotting import figure,show
import collections
from estadisticas import desviacion_estandar,media

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros=[]

    for _ in range(numero_de_tiros):
        tiro_1=random.choice([1,2,3,4,5,6])
        tiro_2=random.choice([1,2,3,4,5,6])
        
        secuencia_de_tiros.append(tiro_1+tiro_2)

    return secuencia_de_tiros

def graficar(x,y):
    grafica=figure(title='Distribucion normal',x_axis_label='sigma',y_axis_label='valores')
    grafica.vbar(x,top=y ,legend='Distribucion normal')
    show(grafica)



def main(numero_de_tiros,numero_de_intentos):
    X=[] #Almacenaremos los resultados de las veces que corramos la simulacion
    
    
    for _ in range(numero_de_intentos):
        secuencia_de_tiros=tirar_dado(numero_de_tiros)
        X.append(media(secuencia_de_tiros)) #Añadimos la secuencia al arreglod e tiros

 
    counter = dict(collections.Counter(X))
    
    x=list(counter.keys()) #Para X iran las letras es decir, sigma1 sigma 2 etc
    y=list(counter.values()) #Para Y iran los valores de las medias

    graficar(x,y)

if __name__ == "__main__":

    numero_de_tiros=int(input('Cuantos tiros del dado: '))
    numero_de_intentos=int(input('Cuantos intentos quieres hacer?: '))

    main(numero_de_tiros,numero_de_intentos)

Acá lo refuerza con un ejemplo que me ayudó a entender las gráficas que han publicado los compañeros
https://www.youtube.com/watch?v=EC1bTDBz46k

Algoritmo para comprobar el teorema del límite central

import random
import collections
import sys

sys.path.append('../')

from estadisticas import desviacion_estandar, media

from bokeh.plotting import figure, show

OPCIONES_DADOS = [1,2,3,4,5,6]

def tirar_dados(numero_intentos):
    secuencia_tiros = []
    for _ in range(numero_intentos):
        dado_1 = random.choice(OPCIONES_DADOS)
        dado_2 = random.choice(OPCIONES_DADOS)
        tiro = dado_1 + dado_2
        secuencia_tiros.append(tiro)
    
    return secuencia_tiros

def graficar(x,y):
    plot = figure(title='Distribucion normal', x_axis_label='media', y_axis_label='tiros')
    plot.vbar(x, top=y, width=0.5, color='green')
    show(plot)

def main(numero_intentos):
    total_tiros = tirar_dados(numero_intentos)

    media_tiros = media(total_tiros)
    sigma = desviacion_estandar(total_tiros)

    contador_tiros = dict(collections.Counter(total_tiros))
    print(f'Media: {round(media_tiros, 10)}, Sigma: {round(sigma, 10)}')

    graficar(list(contador_tiros.keys()), list(contador_tiros.values()))


if __name__ == "__main__":
    numero_intentos = int(input('Numero de veces a lanzar los dados: '))
    main(numero_intentos)

Hola! Este es mi código, básicamente lo que hace es:

Simular el lanzamiento de dos dados, dicho lanzamiento se realiza “n veces” y los resultados se guardan en una lista y a partir de esa lista la cual seria nuestra población, sacaremos “n muestras aleatoria de tamaño n” y a dichas muestras se le calcula la media (“X sombrero”) y se guarda en una lista, seguidamente se gráfica a las medias muestrales (media de las muestras) obtenidas:

"""
Simulación de tirar dos dado sumar el resultado y aplicar el teorema 
de limite central para obtener una distribuciíon normal.

El usuario introduce:
:numero_de_tiros :Cuanto tiros quiere realizar el usuario
:numero_de_muestras: numeros de muestras.
:tamano_muestra: Tamaño de las muestras o el  numero de elementos que tendra las muetras.
"""
import random
from bokeh.plotting import figure
from bokeh.io import output_file,show
from estadisticas import media
import collections

def graficar(data,title="Grafica"):
    output_file(f'teorema_limite_central_grafica_{title}.html')
    counter = dict(collections.Counter(data))
    x,y = list(counter.keys()),list(counter.values())
    p = figure(title=title,
            toolbar_location=None, tools="",x_axis_label='Numero del dado', y_axis_label='Cantidad de veces')

    p.vbar(x, top=y)

    p.xgrid.grid_line_color = None
    p.y_range.start = 0
    p.x_range.range_padding = 2
    show(p)

def tirar_dados(numero_de_tiros):
    secuencia_tiros = []
    for _ in range(numero_de_tiros):
        tiro = random.choice([1,2,3,4,5,6]) + random.choice([1,2,3,4,5,6])
        secuencia_tiros.append(tiro)
    media_poblacion = media(secuencia_tiros)
    print(f'La media de la población es: {media_poblacion}')
    return secuencia_tiros

def sample_medias(tiros,numero_de_muestras,tamano_muestra):
    medias_muestral = []
    for _ in range(numero_de_muestras):
        tiros_choices = []
        for _ in range(tamano_muestra):
            tiros_choices.append(random.choice(tiros))
        medias_muestral.append(round(media(tiros_choices),3))

    return medias_muestral
        
    
def main(numero_de_tiros,numero_de_muestras,tamano_muestra):
    tiros = tirar_dados(numero_de_tiros)
    #graficar(tiros,title='tiros') # Grafica los tiros
    
    medias = sample_medias(tiros,numero_de_muestras,tamano_muestra)
    media_normal = media(medias)
    graficar(medias,title='medias')
    print(f'La media normal es: {media_normal}')



if __name__ == '__main__':
    numero_de_tiros = int(input("Ingrese el número de tiros: "))
    numero_de_muestras = int(input("Ingrese el numero de muestras: "))
    tamano_muestra = int(input("Ingrese el tamano de la muestra: "))
    
    main(numero_de_tiros,numero_de_muestras,tamano_muestra)

Les dejo mi código para el reto 😃

import random
from bokeh.plotting import figure, output_file, show
from collections import Counter

def throw_dice(n_throws):
    throw_sequence = []
    for _ in range(n_throws):
        throw = random.choice([1,2,3,4,5,6])
        throw_sequence.append(throw)
    return throw_sequence

def simulate_throws(n_throws, simulation_times):
    throws = []
    for _ in range(simulation_times):
        throw_sequence = throw_dice(n_throws)
        throws.extend(throw_sequence)
    return throws

def average_sum(throws_A, throws_B):
    dice_sum = [throws_A[i] + throws_B[i] for i in range(len(throws_A)) ]
    return [dice_sum, sum(dice_sum)/len(throws_A)]

if __name__ == "__main__":
    simulation_times = 10000
    throws_A = simulate_throws(1, simulation_times)
    throws_B = simulate_throws(1, simulation_times)
    sums, ave_sum = average_sum(throws_A, throws_B)
    print(f'The average sum is {ave_sum}')
    
    counter_sums = Counter(sums)
    x_vals = []
    y_vals = []
    for key,value in counter_sums.items():
        x_vals.append(key)
        y_vals.append(value)
    
    fig = figure(title = f"Distribution of the sum of two dice over {simulation_times} simulations; the average sum is {ave_sum}")
    fig.vbar(x= x_vals, top= y_vals, color="green", width=0.9)
    output_file('barplot.html')
    show(fig)
    

Por lo que pude entender el Teorema de Limite central significa que el promedio pequeños grupos pueden darte la distribucion Normal de una caracteristica especifica.
Un ejemplo imgania que quieres hallar la distribucion de altura de todos los varones de un pais, asi que sales a la calle y preguntas 100 ‘grupos’ de una persona, al hacer la grafica te saldra ua media similar a la del pais pero habra un gran variacion estandar, asi que vuelves a salir pero esta vez solo preguntas a grupos de 4 personas y a cada grupo le sacas su media y vuelves a hacer la distribucion,la media no ha cambiado mucho pero la variacion estandar si,ha disminuido en un factor “Variacion/(4)**0.5”

Todo se resume a esto:
La media de LAS MEDIAS de CUALQUIER DISTRIBUCIÓN tiende a ser una distribución normal

Nuevas cosas por aprender

import random
import matplotlib.pyplot as plt
import collections


def tirar_dado(numero_de_lanzamientos):
    secuencia_de_tiros=[]
    
    for _ in range (numero_de_lanzamientos):
        tiro =random.choice ([1,2,3,4,5,6])
        secuencia_de_tiros.append(tiro)
    
    return secuencia_de_tiros

def main (intentos,numero_de_lanzamientos):
    medias =[]

    for _ in range(intentos):
        muestra= tirar_dado (numero_de_lanzamientos)

        media = sum(muestra)/len(muestra)
        medias.append(media)
        count= dict (collections.Counter(medias))
      
        plt.bar (count.keys(),count.values(),color="r")
        plt.xlabel('media')
        plt.ylabel('intentos')
        plt.title('Tirar un dado')

        plt.show()
   

if __name__=="__main__":

    intentos=int (input("cuantos intentos quiere hacer:  "))
    numero_de_lanzamientos= int (input("Cuantos lanzamientos desea : "))
    
    main( intentos,numero_de_lanzamientos)

Buena explicacion del Teorema del Limite Central

Excelente. Por mi parte hice el reto de dados con 10 lanzamientos y 1 millón de intentos.
Les adjunto mi código y lo que me genero.

import random
import matplotlib.pyplot as plt
import collections

def lanzar_dados( numero_lanzamientos ):
    lanzamientos = []

    for _ in range(numero_lanzamientos):
        lanzamiento = random.choice([1,2,3,4,5,6])
        lanzamientos.append(lanzamiento)
    return lanzamientos

def main(intentos, lanzamientos):
    medias = []

    for _ in range(intentos):
        muestra = lanzar_dados(lanzamientos)
        media = sum(muestra) / len(muestra)
        medias.append(media)
    count = dict(collections.Counter(medias))

    plt.bar(count.keys(),count.values(), color='y')
    plt.show()

if __name__ == '__main__':
    
    main(1000000,10)

Os dejo este video que explica bastante bien el teorema del limite central: https://www.youtube.com/watch?v=46DgBP9VwtE

Para reforzar, muy bien explicado:

https://youtu.be/ff6-YnGv6Gg

El Teorema del Límite Central fue la razón por la que se pudo estimar PI en varias simulaciones (hace dos videos) 😄

Hice el ejercicio que propuso David, utilicé un código que habíamos hecho anteriormente, con la diferencia que calculé su media. En ella corrí varias veces el código y siempre me daba una media de 7.00 al redondear a 2 decimales. Adjunto el código y el último resultado que me arrojó la simulación.

"""
Created on Wed Jan 13 16:06:28 2021

@author: Fernando Baladi
"""

import random
import matplotlib.pyplot as plt
from media import media

def tirar_dados(numero_de_tiros):
    secuencia_de_tiros = []
    
    for _ in range(numero_de_tiros):
        tiro1 = random.choice([1,2,3,4,5,6])
        tiro2 = random.choice([1,2,3,4,5,6])
        tiro = tiro1 + tiro2
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numero_de_tiros)
        tiros = tiros + (secuencia_de_tiros)

     
    plt.hist(tiros)
    plt.show()
    print(f'La media de tiros es de {round(media(tiros),2)}')    
    
if __name__ =='__main__':
    numero_de_tiros = int(input('Ingrese el número de tiros: '))
    numero_de_intentos = int(input('Cuántas veces correrá la simulación: '))
    
    main(numero_de_tiros, numero_de_intentos)
    

El número de tiros fue 1 y se corrió la simulación 50.000 veces.
Y su media fue de 7.0

bastante útil