introduction

Lors de l'étude des tests statistiques, diverses distributions de probabilités apparaissent, mais je pense qu'il est difficile d'obtenir une image simplement en regardant les formules mathématiques. Tout en déplaçant divers paramètres avec Python, dessinez la distribution de probabilité et attachez l'image.

référence

Pour l'explication de la distribution de probabilité, reportez-vous à ce qui suit.

Diverses distributions de probabilité

Cet article ne donne pas d'explications détaillées telles que la dérivation de diverses formules mathématiques, mais se concentre sur la compréhension de la forme de chaque distribution et la signification de cette distribution. Cet article traite des deux distributions suivantes.

Distribution bimétrique
Distribution de poissons

Distribution binaire

Le nombre d'essais $ n $ réussis (essais de Bernouy) qui n'ont que deux conséquences, par exemple "si le recto ou le verso sort quand une pièce est lancée" La distribution qui suit est appelée distribution binomiale **.

――Le nombre de fois que vous lancez les dés 10 fois et obtenez 1 ――Le nombre de fois où le tableau apparaît lorsque vous lancez une pièce 5 fois ――Le nombre de fois où une équipe de baseball avec un taux de victoire de 70% joue 144 matchs et gagne

Etc. suivent une distribution binomiale.

La formule de la fonction de masse stochastique de la distribution binomiale est exprimée comme suit.


P(X = k) = {}_n C _kp^k(1-p)^{n-k}

$ n $ est le nombre d'essais, $ p $ est la probabilité de succès de l'essai et $ k $ est le nombre d'essais réussis.

De plus, lorsque la variable de probabilité $ X $ suit une distribution binomiale, la valeur attendue $ E (X) $ et la variance $ V (X) $ sont les suivantes.


E(X) = np


V(X) = np(1 - p)

Je pense que la valeur attendue est le produit du nombre d'essais $ n $ et de la probabilité de succès $ p $, ce qui correspond au sentiment.

Maintenant, dessinons une distribution de probabilité en Python. Lorsque vous effectuez 50 $ d'essais avec une probabilité de succès de 10 $ % $, vérifiez la distribution du nombre de succès.

import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()

def comb_(n, k):
    result = math.factorial(n) / (np.math.factorial(n - k) * np.math.factorial(k))
    return result


def binomial_dist(p, n, k):
    result = comb_(n, k) * (p**k) * ((1 - p) ** (n - k))
    return result

x =  np.arange(1, 50, 1)

y = [binomial_dist(a, 50, i) for i in x]

plt.bar(x, y, align="center", width=0.4, color="blue", 
             alpha=0.5, label="binomial p= " + "{:.1f}".format(a))

plt.legend()
plt.ylim(0, 0.3)
plt.xlim(0, 50)

plt.show()
plt.savefig('binomial_dist_sample.png')

Puisque la probabilité de succès est de 10 $ % $, vous pouvez voir que la probabilité de succès est toujours la plus élevée pour 4,5 $. Il correspond également que la valeur attendue est $ np = 50 × 0,1 = 5 $. Vous pouvez également voir que les chances de succès au-dessus de 10 $ sont très faibles et 20 $ est un niveau miracle.

Voyons maintenant comment la distribution change à mesure que nous augmentons le taux de réussite (change $ p $).

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
%matplotlib notebook

def comb_(n, k):
    result = math.factorial(n) / (np.math.factorial(n - k) * np.math.factorial(k))
    return result


def binomial_dist(p, n, k):
    result = comb_(n, k) * (p**k) * ((1 - p) ** (n - k))
    return result

fig = plt.figure()

def update(a):
    plt.cla() 
    x =  np.arange(1, 50, 1)
    y = [binomial_dist(a, 50, i) for i in x]

    plt.bar(x, y, align="center", width=0.4, color="blue", 
                 alpha=0.5, label="binomial p= " + "{:.1f}".format(a))
    
    plt.legend()
    plt.ylim(0, 0.3)
    plt.xlim(0, 50)
    
    
ani = animation.FuncAnimation(fig,
                              update,
                              interval=1000,
                              frames = np.arange(0.1, 1, 0.1),
                              blit=True)
plt.show()
ani.save('Binomial_dist.gif', writer='pillow')

Vous pouvez voir que plus $ p $ est proche de 0,5 $ (la probabilité de succès est de 50 $ % $), plus la queue de la distribution est large et plus elle est proche de 0 $ ou 1 $, plus la forme est nette. En regardant la formule de $ V (X) = np (1-p) $, nous pouvons voir que plus $ p $ est proche de 0,5 $ $, plus la valeur de la variance est grande. Si le taux de réussite est égal, les résultats varieront en conséquence, ce qui correspond au sentiment.

Distribution de Poisson

Vient ensuite la distribution de Poisson. La distribution de probabilité qui représente la probabilité qu'un événement qui se produit en moyenne $ \ lambda $ fois par unité de temps se produise exactement $ k $ fois ** est appelée distribution de Poisson.

--Nombre de véhicules passant par une intersection spécifique en une heure --Nombre d'accès au site en une heure --Nombre d'e-mails reçus par jour --Nombre de visiteurs du magasin au cours d'une certaine période de temps

On dit que etc. suivent la distribution de Poisson.

La formule de la fonction de masse de probabilité de distribution de Poisson est exprimée comme suit.

P(X=k) = \frac{\lambda^k \mathrm{e}^{-\lambda}}{k!}

C'est une formule très déroutante, mais si vous voulez connaître le processus de dérivation détaillé, veuillez consulter Article précédent. La valeur attendue $ E (X) $ et la variance $ V (X) $ lorsque la variable de probabilité $ X $ suit la distribution de Poisson sont les suivantes.


E(X) = \lambda


V(X) = \lambda

Puisque nous parlons d'événements qui se produisent en moyenne $ \ lambda $ fois, il est compréhensible que la valeur attendue soit $ \ lambda $ telle quelle.

Maintenant, dessinons une distribution de probabilité en Python. Superposons la distribution de Poisson pour voir ce que chacun des événements qui se produisent en moyenne 5 $ fois, les événements qui se produisent en moyenne 10 $ fois et les événements qui se produisent en moyenne 15 $ fois par unité de temps.


import numpy as np
import matplotlib.pyplot as plt

def poisson(k, lambda_):
    k = int(k)
    result = (lambda_**k) * (np.exp(-lambda_))  / np.math.factorial(k)
    return result

x =  np.arange(1, 50, 1)
y1= [poisson(i, 5) for i in x]
y2= [poisson(i, 15) for i in x]
y3= [poisson(i, 30) for i in x]

plt.bar(x, y1, align="center", width=0.4, color="red"
                ,alpha=0.5, label="Poisson λ= %d" % 5)

plt.bar(x, y2, align="center", width=0.4, color="green"
                ,alpha=0.5, label="Poisson λ= %d" % 15)

plt.bar(x, y3, align="center", width=0.4, color="blue"
                ,alpha=0.5, label="Poisson λ= %d" % 30)

plt.legend()
plt.savefig('Poisson_sample.png')
plt.show()

Puisque la valeur de $ \ lambda $ est égale et distribuée, plus la valeur de $ \ lambda $ est grande, plus la base de la distribution de probabilité est large. En regardant le mouvement du changement dans la distribution lorsque $ \ lambda $ est augmenté, cela ressemble à ceci.


import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
from scipy.stats import poisson
fig = plt.figure()

def update(a):
    plt.cla()
    
    x =  np.arange(1, 50, 1)

    y = [poisson.pmf(i,a) for i in x]

    plt.bar(x, y, align="center", width=0.4, color="red", 
                 alpha=0.5, label="Poisson λ= %d" % a)
    
    plt.legend()
    plt.ylim(0, 0.3)
    plt.xlim(0, 50)
    
ani = animation.FuncAnimation(fig,
                              update,
                              interval=500,
                              frames = np.arange(1, 31, 1),
                              blit=True)
plt.show()
ani.save('Poisson_distribution.gif', writer='pillow')

Vous pouvez voir que lorsque la valeur de $ \ lambda $ augmente, la queue de la distribution change. Plus le $ \ lambda $ est élevé, qui est le nombre moyen d'événements qui se produisent par unité de temps, plus le nombre de fois que l'événement se produira variera.

Distribution binaire et distribution de Poisson

La distribution de Poisson est en fait une distribution de probabilité créée à partir de la distribution binomiale. La distribution de Poisson consiste à rapprocher $ n → ∞ $ de $ p → 0 $ tout en gardant $ np = \ lambda $ constant. (Il s'agit de la limitation extrême de Poisson. [Article précédent] (https://qiita.com/g-k/items/836820b826775feb5628) est expliqué, donc si vous êtes intéressé, veuillez y aller. )

En d'autres termes, parmi les événements qui suivent la distribution binomiale, ** les événements qui sont nombreux et se produisent rarement ** suivent la distribution de Poisson.

À titre d'exemple concret, dessinons une distribution binomiale de $ n = 100 $ $ p = 0,1 $ et une distribution de Poisson de $ \ lambda = 1 $.

import numpy as np
import matplotlib.pyplot as plt

def poisson(k, lambda_):
    result = (lambda_**k) * (np.exp(-lambda_))  / np.math.factorial(k)
    return result

def comb_(n, k):
    result = math.factorial(n) / (np.math.factorial(n - k) * np.math.factorial(k))
    return result

def binomial_dist(p, n, k):
    result = comb_(n, k) * (p**k) * ((1 - p) ** (n - k))
    return result

x =  np.arange(1, 100, 1)
y1= [poisson(i, 1) for i in x]
y2 = [binomial_dist(0.01, 100, i) for i in x]

plt.xlim(0, 30)

plt.bar(x, y1, align="center", width=0.4, color="red"
                ,alpha=0.5, label="Poisson λ= %d" % 1)

plt.bar(x, y2, align="center", width=0.4, color="blue", 
                 alpha=0.5, label="binomial p= " + "{:.2f}".format(0.01))

plt.legend()
plt.savefig('bino_poisson.png')
plt.show()

Vous pouvez voir que les distributions se chevauchent presque exactement. En dessinant réellement la distribution de cette manière, il devient plus facile de comprendre la relation entre les distributions.

NEXT La prochaine fois, nous aborderons la «distribution géométrique», la «distribution exponentielle» et la «distribution binomiale négative».