Einführung

Während des Studiums statistischer Tests kommen verschiedene Wahrscheinlichkeitsverteilungen heraus, aber ich denke, es ist schwierig, ein Bild zu erhalten, wenn man nur die mathematischen Formeln betrachtet. Zeichnen Sie beim Verschieben verschiedener Parameter mit Python die Wahrscheinlichkeitsverteilung und hängen Sie das Bild an.

Referenz

Zur Erläuterung der Wahrscheinlichkeitsverteilung wird auf Folgendes verwiesen.

Verschiedene Wahrscheinlichkeitsverteilungen

Dieser Artikel enthält keine detaillierten Erklärungen wie die Ableitung verschiedener mathematischer Formeln, sondern konzentriert sich darauf, die Form jeder Verteilung und die Bedeutung dieser Verteilung zu erfassen. Dieser Artikel befasst sich mit den folgenden zwei Distributionen.

Bimetrische Verteilung --Poisson-Verteilung

Binäre Verteilung

Die Anzahl erfolgreicher $ n $ -Versuche (Bernouy-Versuche), die nur zwei Konsequenzen haben, z. B. "ob die Vorder- oder Rückseite beim Werfen einer Münze herauskommt". Die folgende Verteilung wird als Binomialverteilung ** bezeichnet.

――Die Häufigkeit, mit der Sie 10 Mal würfeln und 1 erhalten ――Die Häufigkeit, mit der die Tabelle angezeigt wird, wenn Sie fünfmal eine Münze werfen ――Die Häufigkeit, mit der eine Baseballmannschaft mit einer Gewinnquote von 70% 144 Spiele spielt und gewinnt

Folgen Sie einer Binomialverteilung.

Die Formel für die stochastische Massenfunktion der Binomialverteilung wird wie folgt ausgedrückt.


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

$ n $ ist die Anzahl der Versuche, $ p $ ist die Erfolgswahrscheinlichkeit des Versuchs und $ k $ ist die Anzahl der erfolgreichen Versuche.

Wenn die Wahrscheinlichkeitsvariable $ X $ einer Binomialverteilung folgt, sind der erwartete Wert $ E (X) $ und die Varianz $ V (X) $ wie folgt.


E(X) = np


V(X) = np(1 - p)

Ich denke, dass der erwartete Wert das Produkt aus der Anzahl der Versuche $ n $ und der Erfolgswahrscheinlichkeit $ p $ ist, die dem Gefühl entspricht.

Zeichnen wir nun eine Wahrscheinlichkeitsverteilung in Python. Wenn Sie $ 50 $ -Versuche mit einer Erfolgswahrscheinlichkeit von $ 10 % $ durchführen, überprüfen Sie die Verteilung der Anzahl der Erfolge.

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')

Da die Erfolgswahrscheinlichkeit $ 10 % $ beträgt, können Sie sehen, dass die Erfolgswahrscheinlichkeit für $ 4,5 $ immer noch am höchsten ist. Es stimmt auch überein, dass der erwartete Wert $ np = 50 × 0,1 = 5 $ ist. Sie können auch sehen, dass die Erfolgschancen über 10 $ sehr gering sind und 20 $ ein Wunderlevel sind.

Nun wollen wir sehen, wie sich die Verteilung ändert, wenn wir die Erfolgsrate erhöhen (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')

Sie können sehen, dass die Form umso schärfer ist, je näher $ p $ an $ 0,5 $ liegt (Erfolgswahrscheinlichkeit ist $ 50 % $), je breiter das Ende der Verteilung ist und je näher es an $ 0 $ oder $ 1 $ liegt. Wenn wir uns die Formel von $ V (X) = np (1-p) $ ansehen, können wir sehen, dass der Varianzwert umso größer ist, je näher $ p $ an $ 0,5 $ liegt. Wenn die Erfolgsquote gerade ist, variieren die Ergebnisse entsprechend, was dem Gefühl entspricht.

Poisson-Verteilung

Als nächstes kommt die Poisson-Verteilung. Die Wahrscheinlichkeitsverteilung, die die Wahrscheinlichkeit darstellt, dass ein Ereignis, das durchschnittlich $ \ lambda $ mal pro Zeiteinheit auftritt, genau $ k $ mal auftritt, wird als Poisson-Verteilung bezeichnet.

Anzahl der Fahrzeuge, die in einer Stunde eine bestimmte Kreuzung passieren
Anzahl der Zugriffe auf die Website in einer Stunde
Anzahl der pro Tag eingegangenen E-Mails
Anzahl der Besucher des Geschäfts innerhalb eines bestimmten Zeitraums

Usw. sollen der Poisson-Verteilung folgen.

Die Formel für die Massenfunktion der Poisson-Verteilungswahrscheinlichkeit wird wie folgt ausgedrückt.

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

Es ist eine sehr verwirrende Formel, aber wenn Sie den detaillierten Ableitungsprozess kennen möchten, lesen Sie bitte Vorheriger Artikel. Der erwartete Wert $ E (X) $ und die Varianz $ V (X) $, wenn die Wahrscheinlichkeitsvariable $ X $ der Poisson-Verteilung folgt, sind wie folgt.


E(X) = \lambda


V(X) = \lambda

Da es sich um Ereignisse handelt, die durchschnittlich $ \ lambda $ mal auftreten, ist es sinnvoll, dass der erwartete Wert so wie er ist \ \ lambda $ ist.

Zeichnen wir nun eine Wahrscheinlichkeitsverteilung in Python. Überlagern wir die Poisson-Verteilung, um zu sehen, welche Ereignisse durchschnittlich 5 US-Dollar pro Zeiteinheit, durchschnittlich 10 US-Dollar und durchschnittlich 15 US-Dollar auftreten.


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

Da der Wert von $ \ lambda $ gleich und verteilt ist, ist die Basis der Wahrscheinlichkeitsverteilung umso breiter, je größer der Wert von $ \ lambda $ ist. Wenn man die Bewegung der Änderung in der Verteilung betrachtet, wenn $ \ lambda $ erhöht wird, sieht es so aus.


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')

Sie können sehen, dass sich mit zunehmendem Wert von $ \ lambda $ das Ende der Verteilung ändert. Je größer $ \ lambda $ ist, dh die durchschnittliche Anzahl von Ereignissen, die pro Zeiteinheit auftreten, desto mehr Ereignisse treten auf.

Binärverteilung und Poisson-Verteilung

Die Poisson-Verteilung ist tatsächlich eine Wahrscheinlichkeitsverteilung, die basierend auf der Binomialverteilung erstellt wird. Die Poisson-Verteilung soll $ n → ∞ $ näher an $ p → 0 $ bringen, während $ np = \ lambda $ konstant bleibt. (Es heißt Poisson Extreme Limitation. [Vorheriger Artikel] (https://qiita.com/g-k/items/836820b826775feb5628) wird erklärt. Wenn Sie also interessiert sind, sehen Sie bitte dort nach. )

Mit anderen Worten, unter den Ereignissen, die der Binomialverteilung folgen, folgen ** Ereignisse, die zahlreich sind und selten auftreten ** der Poisson-Verteilung.

Zeichnen wir als konkretes Beispiel eine binäre Verteilung von $ n = 100 $ p = 0,1 $ und eine Poisson-Verteilung von $ \ 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()

Sie sehen, dass sich die Verteilungen fast genau überlappen. Wenn Sie die Verteilung tatsächlich auf diese Weise zeichnen, wird es einfacher, die Beziehung zwischen den Verteilungen zu verstehen.

NEXT Das nächste Mal werden wir uns mit "geometrischer Verteilung", "Exponentialverteilung" und "negativer Binomialverteilung" befassen.