[PYTHON] Ich habe versucht, die Beziehung zwischen Wahrscheinlichkeitsverteilungen ausgehend von der Bernoulli-Verteilung zusammenzufassen

Einführung

Um die Beziehung zwischen Wahrscheinlichkeitsverteilungen zu verstehen, haben wir Funktionen implementiert und zusammengefasst, die ausgehend von der Bernoulli-Verteilung verschiedene Wahrscheinlichkeitsverteilungen in Python generieren. Dieser Artikel richtet sich an folgende Personen.

• Ich habe die grundlegende Wahrscheinlichkeitsverteilung untersucht
• Ich habe Python berührt
• Ich möchte die Beziehung zwischen Wahrscheinlichkeitsverteilungen verstehen

Die implementierten Python-Funktionen sind wie folgt. Funktionsnamen umfassen bernolli und binom.

Zum Beispiel kann eine gleichmäßige Verteilung erzeugt werden, indem die folgende Reihenfolge befolgt wird. Bernouy-Verteilung-> Geometrische Verteilung-> Exponentialverteilung-> Gamma-Verteilung-> Beta-Verteilung-> Gleichmäßige Verteilung Die Definition des Funktionsnamens und der Wahrscheinlichkeitsverteilung folgt scipy.stats. 　 Lassen Sie uns nun nacheinander jede Funktion erklären.

Bernoulli-Vertrieb

Generieren Sie zunächst eine Stichprobe, die der Bernoulli-Verteilung des Startpunkts folgt. Die Bernoulli-Verteilung ist eine Wahrscheinlichkeitsverteilung, die "der Anzahl der Gewinne folgt, wenn die $ p $ -Lotterie einmal gezogen wird". Wie Sie der Definition entnehmen können, sind die möglichen Werte 0 oder 1. Die stochastische Funktion ist durch die folgende Gleichung gegeben.

f(x;p) = p^x (1-p)^{1-x}\ \ (x=0,1)

Fahren Sie mit der Python-Implementierung fort. Importieren Sie numpy und scipy.stats im Voraus.

import numpy as np
from scipy import stats

Unten finden Sie eine Funktion, die sampleSize-Samples generiert, die der Bernoulli-Verteilung mit einer Wahrscheinlichkeit von $ p $ folgen.

def bernoulli(p, sampleSize):
    return stats.bernoulli.rvs(p, size=sampleSize)

Versuchen wir, aus dieser Funktion 20 Samples zu generieren.

bernoulli(0.2, 20)
> array([1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1])

Je nach Einstellung erscheint 1 mit einer Wahrscheinlichkeit von ca. 0,2. Dies ist das letzte Mal, dass scipy.stats verwendet wird. Danach wird eine Wahrscheinlichkeitsverteilung basierend auf dieser "Bernoulli-Funktion" generiert.

Von der Bernoulli-Verteilung zur Binomialverteilung

Die Binomialverteilung ist eine Wahrscheinlichkeitsverteilung, die "der Anzahl der Gewinne folgt, wenn die Lotterie mit der Chance, $ p $ zu gewinnen, $ n $ mal gezogen wird". Die stochastische Funktion ist durch die folgende Gleichung gegeben.

f(x;n,p) = \left(
\begin{matrix}
n\\
x
\end{matrix}
\right) p^x(1-p)^{n-x}\ \ (x=0,1,\cdots,n)

Die Binomialverteilung ist die "Anzahl der Lotterieverlosungen" in der Bernoulli-Verteilung multipliziert mit $ n $. SampleSize "Stichproben, die aus einer binären Verteilung mit einer Anzahl von $ n $ Versuchen und einer Wahrscheinlichkeit von $ p $ generiert wurden" werden aus $ n \ times $ sampleSize erstellt. "Stichproben, die aus einer Bernoulli-Verteilung mit einer Wahrscheinlichkeit von $ p $ generiert wurden" tun können. Die Implementierung ist wie folgt.

def binom(n, p, sampleSize):
    x = bernoulli(p, n * sampleSize)
    x = x.reshape([n, sampleSize])
    return np.sum(x, axis=0)

Binäre Verteilung zur Poisson-Verteilung

Die Poisson-Verteilung ist eine Wahrscheinlichkeitsverteilung, die "der Anzahl der Gewinne pro Zeiteinheit in einer Lotterie folgt, die $ \ mu $ pro Zeiteinheit gewinnt". Die stochastische Funktion ist durch die folgende Gleichung gegeben.

f(x;\mu) = \frac{\mu^x}{x!}\exp(-\mu)\ \ (x=0,1,\cdots)

Wie Sie unten sehen können, ist die Poisson-Verteilung der Binomialverteilung sehr ähnlich.

Wenn $ n $ in der Binomialverteilung mit $ n $ Trials und $ \ frac {\ mu} {n} $ $ n \ to \ infty $ ist, konvergiert es zu einer Poisson-Verteilung mit einem Durchschnitt von $ \ mu $. Die Implementierung ist wie folgt.

def poisson(mu, sampleSize):
    n = 1000 #Groß genug
    p = mu / n
    return binom(n, p, sampleSize)

Je größer $ n $ ist, desto besser, aber es erhöht den Rechenaufwand. Proben, die der Poisson-Verteilung folgen, wurden aus der Binom-Funktion generiert. Die Binom-Funktion basiert auf der Bernoulli-Funktion. Mit anderen Worten, wir haben die Poisson-Verteilung aus der Bernoulli-Verteilung generiert. Wir werden diese Methode auch in Zukunft anwenden.

Geometrische Verteilung aus der Bernoulli-Verteilung

Die geometrische Verteilung ist eine Wahrscheinlichkeitsverteilung, die "der Anzahl der Versuche folgt, bei denen die Gewinnwahrscheinlichkeit gezogen wird, bis die Lotterie von $ p $ gewonnen ist". Die stochastische Funktion ist durch die folgende Gleichung gegeben.

f(x;p)= p(1-p)^{x-1}\ \ (x=1,2,\cdots)

Aus einer geometrischen Verteilung mit einer Wahrscheinlichkeit von $ p $ erzeugte Proben können aus einer Bernoulli-Verteilung mit einer Wahrscheinlichkeit von $ p $ erzeugt werden. Die Implementierung ist wie folgt.

def geom(p, sampleSize):
    x = []
    for _ in range(sampleSize):
        t = 1
        while bernoulli(1 - p, 1):
            t += 1
        x.append(t)
    return np.array(x)

def geom(p, sampleSize):
    n = 1000  
    x = []
    s = np.array([-1], dtype=int)
    while len(x) < sampleSize:
        x_ = bernoulli(p, n) #Generieren Sie gleichzeitig n Proben, die der Bernoulli-Verteilung folgen.
        x_ = np.where(x_ == 1)[0]
        x_ = np.concatenate([s, x_])
        x.extend(x_[1:] - x_[:-1])
        s = np.array([x_[-1] - n])
    return np.array(x[:sampleSize])

Die beiden Funktionen machen dasselbe, aber ich denke, die erstere ist leichter zu verstehen und die letztere ist schneller.

Negative Binomialverteilung aus der geometrischen Verteilung

Die negative Binomialverteilung ist eine Wahrscheinlichkeitsverteilung, die "der Anzahl der Fehlschläge folgt, wenn die Lotterie mit einer Gewinnwahrscheinlichkeit von $ p $ gezogen wird, bis sie $ n $ Mal gewinnt". Die stochastische Funktion ist durch die folgende Gleichung gegeben.

f(x;n,p) = \left(
\begin{matrix}
n+x-1\\
x
\end{matrix}
\right) p^n(1-p)^{x}\ \ (x=0,1,\cdots,n)

Der einzige wesentliche Unterschied zur geometrischen Verteilung besteht darin, "wie oft Sie im Lotto gewinnen". Wie unten gezeigt, kann aus einer geometrischen Verteilung eine negative Binomialverteilung erstellt werden.

def nbinom(n, p, sampleSize):
    x = geom(p, sampleSize * n) - 1
    x = x.reshape([sampleSize, n])
    return np.sum(x, axis=1)

Von der geometrischen Verteilung zur Exponentialverteilung

Die Exponentialverteilung ist eine Wahrscheinlichkeitsverteilung, die "der Zeit folgt, die benötigt wird, um einen Gewinn in einer Lotterie zu gewinnen, die durchschnittlich $ \ frac {1} {\ lambda} $ pro Zeiteinheit gewinnt". Die Wahrscheinlichkeitsdichtefunktion ist durch die folgende Gleichung gegeben.

f(x,\lambda) = \lambda\exp(-\lambda x)

Die Exponentialverteilung ist der geometrischen Verteilung wie folgt sehr ähnlich.

Die Eigenschaft, dass sich die Trefferwahrscheinlichkeit unabhängig von Zeit oder Versuch nicht ändert, wird als ** Gedächtnislosigkeit ** bezeichnet. Sowohl geometrische als auch exponentielle Verteilungen haben diese Eigenschaft. Sie können eine Exponentialverteilung erstellen, indem Sie in der geometrischen Verteilung $ p \ to0 $ festlegen.

def expon(lam, sampleSize):
    p = 0.01  #Klein genug
    x = geom(p, sampleSize)
    return x * p * lam

Je kleiner $ p $ ist, desto besser, aber es erhöht den Rechenaufwand.

Von der Exponentialverteilung zur Poissonverteilung

Poisson-Verteilungen können sowohl aus Exponentialverteilungen als auch aus Binomialverteilungen erstellt werden. Die Folie in Die schlechte Beziehung zwischen Exponentialverteilung und Poisson-Verteilung ist sehr einfach zu verstehen. Die Folie zeigt die R-Implementierung, aber hier ist die Python-Implementierung.

def poisson_(mu, sampleSize):
    x = []
    while len(x) < sampleSize:
        t = 0
        n = -1
        while t <= 1:
            t += expon(1 / mu, 1)
            n += 1
        x.append(n)
    return np.array(x)

Von der Exponentialverteilung zur Gammaverteilung

Die Gammaverteilung ist eine Wahrscheinlichkeitsverteilung, die "der Zeit folgt, die benötigt wird, um $ \ alpha $ mal in einer Lotterie zu gewinnen, die durchschnittlich $ \ frac {1} {\ lambda} $ pro Zeiteinheit beträgt". Die Wahrscheinlichkeitsdichtefunktion ist durch die folgende Gleichung gegeben.

f(x;\alpha,\lambda)=\frac{\lambda^\alpha}{\Gamma(\alpha)}x^{\alpha-1}\exp(-\lambda x)\ \ (x\ge0)

$ \ Gamma (\ alpha) $ wird jedoch durch die folgende Formel angegeben.

\Gamma(\alpha)=\int_0^\infty t^{\alpha-1}\exp(-t)dt

Der einzige wesentliche Unterschied zur Exponentialverteilung besteht darin, "wie viele Treffer möchten Sie sehen?" Die Gammaverteilung kann aus einer Exponentialverteilung gemacht werden.

def gamma(alpha, lam, sampleSize):
    x = expon(lam, sampleSize * alpha)
    x = x.reshape([sampleSize, alpha])
    return np.sum(x, axis=1)

Das Argument $ \ alpha $ der obigen "Gammafunktion" muss eine natürliche Zahl sein. Alles ist in Ordnung, solange $ \ alpha $ der allgemeinen Gammaverteilung eine positive Zahl ist, aber wenn es sich nicht um eine natürliche Zahl handelt, kann es nicht aus der Bernoulli-Verteilung gemacht werden und ist schwer zu erklären, daher werde ich es hier auf natürliche Zahlen beschränken. tat.

Negative Binomialverteilung zur Gammaverteilung

Die Gammaverteilung kann auch aus einer negativen Binomialverteilung erstellt werden. Die Gammaverteilung und die negative Binomialverteilung sind wie folgt sehr ähnlich.

Das Erstellen einer Gammaverteilung aus einer negativen Binomialverteilung entspricht genau dem Erstellen einer Exponentialverteilung aus einer geometrischen Verteilung.

def gamma_(alpha, lam, sampleSize):
    p = 0.01  #Klein genug
    x = nbinom(alpha, p, sampleSize)
    return x * p * lam

Auch hier muss das Argument $ \ alpha $ eine natürliche Zahl sein.

Binäre Verteilung zur Normalverteilung

Wenn eine Verteilung unendlich addiert wird, wird sie zu einer Normalverteilung (zentrale Polbegrenzung). In meinem ersten Artikel "Überprüfung der apokalyptischen Natur der Wahrscheinlichkeitsverteilung in Python" gibt es ein Beispiel. Die Binomialverteilung war die Summe von $ n $ der Bernoulli-Verteilung. Die Binomialverteilung folgt einer Normalverteilung, indem $ n \ auf \ infty $ gesetzt wird. Die Wahrscheinlichkeitsdichtefunktion der Normalverteilung mit dem Mittelwert $ \ mu $ und der Varianz $ \ sigma ^ 2 $ ist durch die folgende Gleichung gegeben.

f(x;\mu,\sigma^2)=\frac{1}{\sqrt{2\pi\sigma^2}}\exp\biggl\{-\frac{(x-\mu)^2}{2\sigma^2}\biggr\}

Stichproben, die einer Normalverteilung mit dem Mittelwert $ \ mu $ und der Standardabweichung $ \ sigma $ folgen, können auf folgende Weise generiert werden:

def norm(mu, sigma, sampleSize):
    n = 1000 #Groß genug
    p = 0.5
    x = binom(n, p, sampleSize)
    sd = (n * p * (1 - p)) ** 0.5
    x = (x - n * p) / sd * sigma + mu
    return x

Von der Normalverteilung zur Chi-Quadrat-Verteilung

Ich kann es nicht wie eine Lotterie erklären, aber die $ \ chi ^ 2 $ -Verteilung erscheint oft beim Testen von Hypothesen. Wenn $ X_1, X_2, \ cdots, X_ {df} $ unabhängig der Standardnormalverteilung folgen (Normalverteilung mit Mittelwert 0, Varianz 1), $ X_1 ^ 2 + X_2 ^ 2 + \ cdots + X_ {df} ^ 2 $ heißt die $ \ chi ^ 2 $ -Verteilung mit $ df $ Freiheit. Die Implementierung ist wie folgt.

def chi2(df, sampleSize):
    x = norm(0, 1, sampleSize * df) ** 2
    x = x.reshape([sampleSize, df])
    return np.sum(x, axis=1)

Gammaverteilung aus Chi-Quadrat-Verteilung

Auch hier kann ich es nicht wie eine Lotterie erklären, aber die $ \ chi ^ 2 $ -Verteilung mit 1 Freiheitsgrad stimmt mit der Gammaverteilung mit $ \ alpha = 1/2 $ und $ \ lambda = 1/2 $ überein. Aufgrund der Eigenschaft ** Regeneration ** der Gammaverteilung ist es möglich, eine Gammaverteilung zu generieren, wenn $ \ alpha $ $ n $ mal ($ n $ ist eine natürliche Zahl) von $ \ frac {1} {2} $ ist. Die Reproduzierbarkeit wird am Ende erklärt.

def gamma__(alpha, lam, sampleSize):
    df = int(np.round(alpha * 2))
    x = chi2(1, sampleSize * df)
    x = x.reshape([sampleSize, df])
    x = x * lam / 2
    return np.sum(x, axis=1)

Das Argument $ \ alpha $ dieser Funktion muss $ n $ mal ($ n $ ist eine natürliche Zahl) von $ \ frac {1} {2} $ sein.

Gamma-Verteilung zur Beta-Verteilung

Dies kann nicht wie eine Lotterie erklärt werden, sondern basiert auf "Gammaverteilung mit den Parametern $ (\ alpha, \ lambda) $" und "Gammaverteilung mit den Parametern $ (\ beta, \ lambda) $". Kann eine Beta-Verteilung von $ (\ alpha, \ beta) $ generieren. Die Dichtefunktion der Beta-Verteilung ist durch die folgende Gleichung gegeben.

f(x;\alpha,\beta)=x^{\alpha-1}(1-x)^{\beta-1}\ \ (0\le x\le 1)

Da der Bereich 0 bis 1 beträgt, wird er häufig als vorherige Verteilung von Parametern verwendet, die die Wahrscheinlichkeit in der Bayes'schen Statistik darstellen.

def beta(alpha, beta, sampleSize):
    x1 = gamma(alpha, 1, sampleSize)
    x2 = gamma(beta, 1, sampleSize)
    return x1 / (x1 + x2)

Beta-Verteilung zur gleichmäßigen Verteilung

Wie aus der Dichtefunktion der Beta-Verteilung hervorgeht, stimmt die Beta-Verteilung mit der Gleichverteilung überein, wenn $ \ alpha, \ beta = 1 $. Proben, die einer gleichmäßigen Verteilung folgen, können aus einer Beta-Verteilung entnommen werden.

def uniform(sampleSize):
    return beta(1, 1, sampleSize)

Zusammenfassung

Die Beziehung untereinander ist auf einen Blick klar.

Lassen Sie uns nun über ** Spielbarkeit ** sprechen. Reproduzierbarkeit ist die Fähigkeit, das Hinzufügen von Verteilungen durch das Hinzufügen von Parametern zu ersetzen. Zum Beispiel

1. X die Binomialverteilung mit $ n $ Anzahl der Versuche und $ p $ Wahrscheinlichkeit
2. Y-binäre Verteilung mit $ m $ Anzahl der Versuche und $ p $ Wahrscheinlichkeit

Dann folgt $ X + Y $ einer Binomialverteilung mit $ (n + m) $ Versuchen und $ p $ Wahrscheinlichkeit. Da 1. gleich der Summe von $ n $ Bernoulli-Verteilungen und 2. gleich der Summe von $ m $ Bernoulli-Verteilungen ist, ist $ X + Y $ die Summe von $ (n + m) $ Bernoulli-Verteilungen. Das heißt, die Anzahl der Versuche entspricht der Binomialverteilung von $ (n + m) $. Nach der gleichen Theorie hat die Verteilung an der Spitze des "Pluralisierungs" -Pfeils in der obigen Figur immer die Eigenschaft der Reproduzierbarkeit (binäre Verteilung, negative Binomialverteilung, Gammaverteilung, $ \ chi ^ 2 $ -Verteilung). Und natürlich sind auch die Normalverteilung und die Poisson-Verteilung, die die Grenzen der Binomialverteilung darstellen, reproduzierbar.

Endlich Python-Experiment

Versuchen Sie Bernouy-Verteilung-> Geometrische Verteilung-> Exponentialverteilung-> Gamma-Verteilung-> Beta-Verteilung-> Gleichmäßige Verteilung-> Bernoulli-Verteilung.

Definieren Sie die Funktion zum Plotten im Voraus.

import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style='whitegrid')

def plot_descreteDitribution(sample, truePf, xmin, xmax):
    sampleSize = len(sample)
    x = np.arange(xmin, xmax + 1)
    pf = np.array([np.sum(sample == i) for i in x]) / sampleSize  #Verteilung durch Experiment erhalten
    
    #Tragen Sie die im Experiment erhaltene Verteilung in Blau auf
    plt.plot(x - 0.1, pf, 'bo', ms=8)
    plt.vlines(x - 0.1, 0, pf, colors='b', lw=5, alpha=0.5)

    #Zeichnen Sie die wahre Verteilung in rot
    plt.plot(x + 0.1, truePf(x), 'ro', ms=8)
    plt.vlines(x + 0.1, 0, truePf(x), colors='r', lw=5, alpha=0.5)

def plot_continuousDitribution(sample, truePf, xmin, xmax):
    sampleSize = len(sample)
    x = np.linspace(xmin, xmax, 100)

    #Tragen Sie die im Experiment erhaltene Verteilung in Blau auf
    th = np.linspace(xmin, xmax, 30)
    hi = np.array([np.sum(np.logical_and(th[i] < sample, sample <= th[i + 1])) for i in range(30 - 1)]) / (sampleSize * (th[1] - th[0]))
    plt.bar((th[:-1] + th[1:]) / 2, hi, width=(th[1] - th[0]))

    #Zeichnen Sie die wahre Verteilung in rot
    plt.plot(x, truePf(x), 'r', linewidth=4)

    plt.xlim(xmin, xmax)

Geometrische Verteilung (aus der Bernoulli-Verteilung)

p = 0.2
xmin = 1
xmax = 20

sample = geom(p, sampleSize)
truePf = lambda x: stats.geom.pmf(x, p)
plot_descreteDitribution(sample, truePf, xmin, xmax)

--Ergebnis

Rot ist die von scipy.stats erstellte Verteilung, und Blau ist die Verteilung, die aus der diesmal erstellten Funktion erstellt wurde. Die sampleSize wurde auf 10000 gesetzt. Gleiches gilt danach.

Exponentialverteilung (aus Bernoulli-Verteilung-> geometrische Verteilung)

lam = 2
xmin = 0
xmax = 10

sample = expon(lam, sampleSize)
truePf = lambda x: stats.expon.pdf(x, scale=lam)
plot_continuousDitribution(sample, truePf, xmin, xmax)

--Ergebnis

Gammaverteilung (aus Bernoulli-Verteilung-> Geometrische Verteilung-> Exponentialverteilung)

alpha = 3
lam = 2
xmin = 0
xmax = 20

sample = gamma(alpha, lam, sampleSize)
truePf = lambda x: stats.gamma.pdf(x, alpha, scale=lam)
plot_continuousDitribution(sample, truePf, xmin, xmax)

--Ergebnis

Beta-Verteilung (aus Bernoulli-Verteilung-> ...-> Gamma-Verteilung)

alpha = 3
bet = 2
xmin = 0
xmax = 1

sample = beta(alpha, bet, sampleSize)
truePf = lambda x: stats.beta.pdf(x, alpha, bet)
plot_continuousDitribution(sample, truePf, xmin, xmax)

--Ergebnis

Gleichmäßige Verteilung (aus Bernoulli-Verteilung-> ...-> Beta-Verteilung)

xmin = 0
xmax = 1

sample = uniform(sampleSize)
truePf = lambda x: stats.uniform.pdf(x)
plot_continuousDitribution(sample, truePf, xmin, xmax)

--Ergebnis

Bernoulli-Verteilung (von Bernoulli-Verteilung-> ...-> Gleichverteilung)! ??

p = 0.2
xmin = -2
xmax = 4

def bernoulli_(p, sampleSize):
    x = uniform(sampleSize)    
    return (x < p).astype(int)

sample = bernoulli_(p, sampleSize)
truePf = lambda x: stats.bernoulli.pmf(x, p)
plot_descreteDitribution(sample, truePf, xmin, xmax)

--Ergebnis

Sie können sehen, dass es funktioniert hat.

Verweise

• Verschiedene Wahrscheinlichkeitsverteilungen und ihre Beziehungen
• Zusammenfassung der Merkmale einer typischen Wahrscheinlichkeitsverteilung
• scipy.stats
• Bestätigen Sie den erschwerenden Charakter der Wahrscheinlichkeitsverteilung mit Python
• Freche Beziehung zwischen Exponentialverteilung und Poisson-Verteilung
• Bestehen der ersten Stufe des statistischen Tests