No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Teorema del L铆mite Central

21/24
Recursos

Aportes 87

Preguntas 5

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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()```

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 鈥減rogramita鈥 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).

鈥淓s 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

<h3>Teorema del l铆mite central.</h3>
  • 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!

<h4>Teorema del l铆mite central</h4>
  • 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 鈥榯ama帽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 estn 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铆 estn 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 鈥渘 veces鈥 y los resultados se guardan en una lista y a partir de esa lista la cual seria nuestra poblaci贸n, sacaremos 鈥渘 muestras aleatoria de tama帽o n鈥 y a dichas muestras se le calcula la media (鈥淴 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 鈥榞rupos鈥 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 鈥淰ariacion/(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:

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