[Python] Memorandum über zufällige Generationen

Wann immer ich versuche, Zufallszahlen zu generieren, kann ich mich nicht erinnern, welche Funktion ich verwenden soll. Deshalb habe ich ein Memorandum mit Funktionen zur Generierung von Zufallszahlen zusammengestellt, die wahrscheinlich häufig verwendet werden.

Insbesondere die Zufallszahlen, die aus den verschiedenen Wahrscheinlichkeitsverteilungen in der zweiten Hälfte generiert werden, werden mit Grafiken und Bildern dargestellt. Ich denke, dies ist nützlich, um die Wahrscheinlichkeitsverteilung selbst zu verstehen. Insbesondere machte ich mir Sorgen um die Chi-Quadrat-Verteilung, weil ich das Bild in der Vergangenheit nicht kannte und versuchte, es intuitiv zu erklären.

Im Folgenden wird unter der Annahme beschrieben, dass die folgenden Bibliotheken importiert werden.

import numpy as np
import numpy.random as rd
import scipy.stats as st
import matplotlib.pyplot as plt

Zufallszahl des Gleichverteilungssystems

rand(d0, d1, ..., dn)###

x = rd.rand(2, 3)
print x

result

[[ 0.49748253  0.88897543  0.65014384]
 [ 0.68424239  0.19667014  0.83407881]]

Erzeugen Sie eine gleichmäßige Verteilung von [0, 1). Die Anzahl der Elemente in der Dimension der generierten Zufallszahl kann im Argument angegeben werden. Im obigen Beispiel sind es 2 Zeilen und 3 Spalten. Erzeugt eine Zufallszahl ohne Argumente.

randn(d0, d1, ..., dn) ###

x1 = rd.randn(2, 4)
print x1

x2 = 2.5 * rd.randn(3, 3) + 3
print x2

result

[[-0.42016216  0.41704326 -0.93713613  0.23174941]
 [-0.95513093  1.00766086 -0.5724616   1.32460314]]

[[-1.51762436  4.88306835  3.21346622]
 [ 0.93229257  4.0592773   4.99599127]
 [ 3.77544739 -0.20112058  2.47063097]]

Erzeugt Zufallszahlen, die aus einer Normalverteilung mit einem Mittelwert von 0 und einer Standardabweichung von 1 generiert werden. Die Anzahl der Elemente in der Dimension der generierten Zufallszahl kann im Argument angegeben werden. Im obigen Beispiel sind es 2 Zeilen und 4 Spalten. Erzeugt eine Zufallszahl ohne Argumente. Wenn Sie den Durchschnitt und die Standardabweichung angeben möchten, schreiben Sie als sigma * rd.randn () + mu.

randint(low, high=None, size=None) ###

x = rd.randint(low=0, high=5, size=10)
print x
li = np.array([u"Mathematik", u"Wissenschaft", u"Gesellschaft", u"Landessprache", u"Englisch"])

for l in li[x]:
    print l

result

[2 0 1 0 0 0 1 3 1 4]
Gesellschaft
Mathematik
Wissenschaft
Mathematik
Mathematik
Mathematik
Wissenschaft
Landessprache
Wissenschaft
Englisch

Erzeugt eine ganzzahlige Zufallszahl, die aus der diskreten Gleichverteilung in dem durch das Argument angegebenen Bereich generiert wird. hoch und Größe kann weggelassen werden. Beachten Sie, dass, wenn hoch nicht weggelassen wird, der Bereich [0, niedrig) eingestellt ist und wenn hoch beschrieben wird, der Bereich [niedrig, hoch) eingestellt ist und beide nicht den oberen Grenzwert enthalten.

Dies ist nützlich, wenn Sie einige Elemente zufällig aus einem bestimmten Array extrahieren möchten.

random_integers(low, high=None, size=None) ###

x = rd.random_integers(low=1, high=10, size=(2,5))
print x

dice = rd.random_integers(1, 6, 100) #Simulation des 100-maligen Würfelns
print dice

result

[[10  5  7  7  8]
 [ 3  5  6  9  6]]

[4 5 2 2 1 1 6 4 5 5 5 5 1 5 1 1 3 2 4 4 5 3 6 6 3 3 5 3 6 1 1 4 1 1 2 1 1
 5 1 6 6 6 6 2 6 3 4 5 1 6 3 1 2 6 1 5 2 3 4 4 3 1 2 1 1 3 5 2 2 1 4 1 6 6
 2 5 4 3 2 1 4 1 2 4 2 5 3 3 1 4 4 1 6 4 1 1 3 6 1 6]

Wie randint () generiert es eine ganzzahlige Zufallszahl, die aus der diskreten Gleichverteilung in dem durch das Argument angegebenen Bereich generiert wird. hoch und Größe kann weggelassen werden. Der Hauptunterschied liegt im Bereich, wenn hoch nicht weggelassen wird, wird der Bereich auf [1, niedrig] gesetzt, wenn hoch beschrieben wird, wird der Bereich auf [niedrig, hoch] gesetzt und nur niedrig wird als "einschließlich der Obergrenze" angegeben. Wenn die Einstellung des Gehäuses "1" ist.

random_sample(size=None), random(size=None), ranf(size=None), sample(size=None) ###

x = np.random.random_sample((4,3))
print x

result

[[ 0.613437    0.38902499  0.91052787]
 [ 0.80291265  0.81324739  0.06631052]
 [ 0.62305967  0.44327718  0.2650803 ]
 [ 0.76565352  0.42962876  0.40136025]]

Wie der Titel schon sagt, gibt es vier Arten: http://stackoverflow.com/questions/18829185/difference-between-various-numpy-random-functions Demnach sind sie alle gleich (außer random_sample sind Aliase). Was zur Hölle (lacht) Der Unterschied zu rand () besteht darin, dass die Argumente so angegeben werden, dass diese durch Taples angegeben werden. Mit rand () können Sie jedoch angeben, dass es selbst mehrere Argumente gibt.

choice(a, size=None, replace=True, p=None) ###

x1=rd.choice(5, 5, replace=False )     # 0-Entspricht der Sortierung 4
print x1

x2=rd.choice(5, 5, p=[0.1,0.1,0.1,0.1,0.6]) #Hohe Wahrscheinlichkeit 4 zu bekommen
print x2

result

[1 4 2 3 0]
[4 4 4 4 2]

Die Struktur des Argumentes der Wahl ist Wahl (a, Größe = Keine, Ersetzen = Wahr, p = Keine). a repräsentiert die zufällige Auswahl aus Bereich (a). Erzeugt die Anzahl der durch die Größe angegebenen Zufallszahlen. Obwohl Ersetzen charakteristisch ist, wird davon ausgegangen, dass es aus dem Bereich (a) abgetastet wird. Wenn jedoch True angegeben wird, wird eine Zufallszahl generiert, ohne die extrahierte Zahl zurückzugeben. Das Gleiche ist nicht zweimal. Wenn daher der Wert von a kleiner als die Größe ist, tritt ein Fehler auf. Obwohl p ebenfalls charakteristisch ist, können Sie die Auftrittswahrscheinlichkeit jeder Zahl anstelle einer einheitlichen Zufallszahl angeben. Wenn daher die Größen von a und p nicht gleich sind, tritt ein Fehler auf.

Andere Zufallszahlen werden bisher von der Python-Standardliste zurückgegeben, dies gibt jedoch den Rückgabewert von numpys ndarray zurück.

shuffle(x) ###

x = range(10)
rd.shuffle(x)
print x

result

[3, 4, 2, 5, 8, 9, 6, 1, 7, 0]

Eine Funktion, die die Reihenfolge eines Arrays zufällig mischt. Beachten Sie, dass das als Argument angegebene Array selbst geändert wird, anstatt es als Rückgabewert zurückzugeben.

permutation(x) ###

x1 = rd.permutation(10)
print x1

li = ['cat', 'dog', 'tiger', 'lion', 'elephant']
x2 = rd.permutation(li)
print x2

result

[4 0 6 5 3 8 7 1 9 2]

['elephant' 'tiger' 'lion' 'dog' 'cat']

Wenn eine Variable vom Typ int als Argument angegeben wird, wird der Bereich (a) intern generiert und zufällig sortiert. Wenn list als Argument angegeben wird, werden die Elemente zufällig sortiert. Der Wert in der Liste ist kein numerischer Wert, sondern kann eine Liste wie eine Zeichenfolge sein.

uniform(low=0.0, high=1.0, size=None) ###

x = rd.uniform(-2,5,30)
print x

result

[-1.79969471  0.6422639   4.36130597 -1.99694629  3.23979431  4.75933857
  1.39738979  0.12817182  1.64040588  3.0256498   0.14997201  2.0023698
  3.76051422 -1.80957115 -0.2320044  -1.82575799  1.26600285 -0.27668411
  0.77422678  0.71193145 -1.42972204  4.62962696 -1.90378575  1.84045518
  1.06136363  4.83948262  3.57364714  1.73556559 -0.97367223  3.84649039]

Erzeugt Zufallszahlen, die aus einer gleichmäßigen Verteilung generiert werden. Der Unterschied zu der bisher erläuterten gleichmäßig verteilten Zufallszahlengenerierungsfunktion besteht darin, dass der Bereich angegeben werden kann. Die Argumentstruktur ist (niedrig = 0,0, hoch = 1,0, Größe = keine) und ein halboffener Abschnitt mit einer offenen Oberseite wie [niedrig, hoch].

Zufallszahl des Wahrscheinlichkeitsverteilungsmodellsystems

Binomial (n, p, Größe = Keine): Binärverteilung

x = rd.binomial(10, 0.5, 20)
print x

result

[5 4 5 5 4 3 8 3 6 6 3 4 5 1 5 7 6 4 2 6]

Erzeugt eine Zufallszahl, die aus der Binomialverteilung generiert wird, wenn der Versuch der Erfolgswahrscheinlichkeit p n-mal durchgeführt wird. Das Folgende kann als Histogramm betrachtet werden, wenn die Wahrscheinlichkeit, 30 Mal einen 0,5-Münzwurf durchzuführen und die Anzahl der Male zu notieren, 3000 Mal ausgeführt wird.

x = rd.binomial(30, 0.5, 3000)
plt.hist(x, 17)

Poisson (lam = 1,0, Größe = keine): Poisson-Verteilung

x = rd.poisson(30, 20)
print x

result

[25 31 38 20 36 29 28 31 22 31 27 24 24 26 32 42 27 20 30 31]

Aus der Poisson-Verteilung wird eine Zufallszahl generiert, die Lam-Zeiten pro Zeiteinheit auftritt. Am Beispiel der Klickrate einer bestimmten Anzeige wird sie auf den Fall angewendet, dass auf die Anzeige 30 Mal pro Stunde geklickt wird.

Das Folgende kann als Histogramm betrachtet werden, wenn durchschnittlich 5 Klicks pro Stunde 1000 Mal versucht werden (= Daten im Wert von 1000 Stunden werden erfasst).

x = rd.poisson(5, 1000)
plt.hist(x, 14)

hypergeometrisch (ngood, nbad, nsample, size = None): Hypergeometrische Verteilung

ngood, nbad, nsamp = 90, 10, 10
x = rd.hypergeometric(ngood, nbad, nsamp, 100)
print x
print np.average(x)

result

[ 9 10  8  9  8  7  7  9 10  7 10  9  9  8  9  9  9  9  8 10  5 10  9  9  9
  9  9 10 10  8 10  9  9  9  7  9  9 10 10  7  9  9 10 10  8  9 10 10  8 10
 10  9  9 10  9 10  8  9  9  9  8  9 10  9 10 10 10  9  9  9 10  9  8 10  7
  7 10 10  9 10 10  9 10  9  7  9  9  8  8 10  7  8  9 10  9  9 10  9  8 10]
8.97

Generieren Sie eine Zufallszahl, die aus einer supergeometrischen Verteilung generiert wird. Zum Beispiel gibt es gute Produkte und schlechte Produkte, und die Anzahl der guten Produkte, die herausgenommen werden können, wenn nsamp-Teile durch die Fehlerratenerhebung extrahiert werden, wird zurückgegeben.

Die folgende Grafik zeigt die Anzahl der guten Produkte, die durch Probenahme von 20 Produkten erhalten wurden, wenn 190 gute Produkte und 10 fehlerhafte Produkte (dh eine Fehlerrate von 5%) in einer Sammelbox mit 200 Produkten vorhanden sind. Es kann als Histogramm der Daten betrachtet werden, wenn dies für 3000 Sammelboxen durchgeführt wird (die genau die gleiche Anzahl guter und fehlerhafter Produkte enthalten).

ngood, nbad, nsamp = 190, 10, 20
x = rd.hypergeometric(ngood, nbad, nsamp, 3000)
plt.hist(x, 6)

geometrisch (p, Größe = keine): Geometrische Verteilung

x = rd.geometric(p=0.01, size=100)
print x

result

[294  36  25  18 171  24 145 280 132  15  65  88 180 103  34 105   3  34
 111 143   5  26 204  27   1  24 442 213  25  93  97  28  80  93   6 189
  90  31 213  13 124  50 110  47  45  66  21   1  88  79 332  80  32  19
  17   2  38  62 121 136 175  81 115  82  35 136  49 810 302  31 147 207
  80 125  33  53  32  98 189   4 766  72  68  10  23 233  14  21  61 362
 179  56  13  55   2  48  41  54  39 279]

Generieren Sie eine Zufallszahl, die aus der geometrischen Verteilung generiert wird. Es wird eine zufällige Anzahl von Malen zurückgegeben, wenn der Versuch mit der Erfolgswahrscheinlichkeit p wiederholt wird, bis er erfolgreich ist.

Die folgende Grafik wiederholt den Versuch mit einer Erfolgswahrscheinlichkeit von 1%, bis er erfolgreich ist, und gibt an, wie oft bis zum Erfolg. Es wird angenommen, dass die Daten, als sie 1000 Mal wiederholt wurden, zu einem Histogramm gemacht wurden.

x = rd.geometric(p=0.01, size=1000)
plt.hist(x, 30)

normal (loc = 0.0, scale = 1.0, size = None): Normalverteilung

x = np.random.normal(5, 2, 20)
print x

result

[-0.28713217  2.07791879  2.48991635  5.36918301  4.32797397  1.40568929
  6.36821312  3.22562844  4.16203214  3.91913171  6.26830012  4.74572788
  4.78666884  6.76617469  5.05386902  3.20053316  9.04530241  5.71373444
  5.95406987  2.61879994]

Es werden Zufallszahlen generiert, die aus der Normalverteilung generiert werden, die der Königsweg der Wahrscheinlichkeitsverteilung ist. loc ist der Durchschnitt und scale ist die Standardabweichung. Unten ist das Histogramm.

x = np.random.normal(5, 2, 10000)
plt.hist(x,20)

Übrigens kann die Zufallszahl, die aus der als nächstes eingeführten Chi-Quadrat-Verteilung erzeugt wird, aus der Kombination der Zufallszahlen erzeugt werden, die aus dieser Normalverteilung und dem Quadrat erzeugt werden.

#Durchschnitt 0,Generieren Sie eine Zufallszahl, die aus einer Normalverteilung mit einer Standardabweichung von 1 generiert wird, und quadrieren Sie ihren Wert
x1 = np.random.normal(0, 1, 10000)**2
x2 = np.random.normal(0, 1, 10000)**2
x3 = np.random.normal(0, 1, 10000)**2
x4 = np.random.normal(0, 1, 10000)**2
x5 = np.random.normal(0, 1, 10000)**2
x6 = np.random.normal(0, 1, 10000)**2

#Das Addieren von zwei Zufallszahlen, die aus der quadratischen Normalverteilung erzeugt werden, ergibt eine Chi-Quadrat-Verteilung mit einem Freiheitsgrad (blaues Diagramm).
plt.hist(x1+x2,20, color='b')
plt.show()
#Wenn Sie drei hinzufügen, wird die Chi-Quadrat-Verteilung mit 2 Freiheitsgraden angezeigt (grüner Graph).
plt.hist(x1+x2+x3,20, color='g')
plt.show()
#Addiere 6 weitere zur Chi-Quadrat-Verteilung mit 5 Freiheitsgraden (rote Grafik)
plt.hist(x1+x2+x3+x4+x5+x6,20, color='r')
plt.show()

chisquare (df, size = None): Chi-Quadrat-Verteilung

x = rd.chisquare(3, 20)
print x

result

[ 0.69372667  0.94576453  3.7221214   6.25174061  3.07001732  1.14520278
  0.92011307  0.46210561  4.16801678  5.89167331  2.57532324  2.07169671
  3.91118545  3.12737954  1.02127029  0.69982098  1.27009033  2.25570581
  4.66501179  2.06312544]

Gibt eine Zufallszahl zurück, die aus einer Chi-Quadrat-Verteilung mit df Freiheitsgraden generiert wurde. Wie im vorherigen Abschnitt erwähnt, ist die Chi-Quadrat-Verteilung eine Verteilung, die dem Quadrat der Zufallszahlen folgt, die aus der Standardnormalverteilung und ihrer Summe generiert werden.

#2 Freiheitsgrade, 5,Ein Histogramm von Zufallszahlen, das durch eine Chi-Quadrat-Verteilung gemäß 20 erzeugt wird
for df, c in zip([2,5,20], "bgr"):
    x = rd.chisquare(df, 1000)
    plt.hist(x, 20, color=c)
    plt.show()

f (dfnum, dfden, size = None): F-Verteilung

x = rd.f(6, 28, 30)
print x

result

[ 0.54770358  0.90513244  1.32533065  0.75125196  1.000936    1.00622822
  1.18431869  0.73399399  0.6237275   1.51806607  1.12040041  1.67777055
  0.40309609  0.29640278  0.49408306  1.97680072  0.51474868  0.28782202
  0.90206995  0.30968917  1.29931934  1.19406178  1.28635087  2.73510067
  0.41310779  1.36155992  0.2887777   0.78830371  0.25557871  0.96761269]

Gibt eine Zufallszahl zurück, die aus einer F-Verteilung mit zwei Freiheitsgraden dfnum und dfden generiert wurde. Diese F-Verteilung ist eine Wahrscheinlichkeitsverteilung, die aus Wahrscheinlichkeitsvariablen besteht, die zwei unabhängigen Chi-Quadrat-Verteilungen im Molekül und Nenner folgen (jeweils geteilt durch den Freiheitsgrad). Die Chi-Quadrat-Verteilung kann als Varianz in dem Sinne angesehen werden, dass sie normalisiert und quadratisch ist. Daher wird sie verwendet, um zu testen, ob die beiden Varianzen gleich sind.

Die folgende Grafik ist ein Histogramm von Zufallszahlen, die aus einer F-Verteilung mit Freiheitsgraden (1,4), (5,7), (10,10) bzw. (40,50) erzeugt wurden.

for df, c in zip([(1,4), (5,7), (10,10), (40,50)], "bgry"):
    x = rd.f(df[0], df[1], 1000)
    plt.hist(x, 100, color=c)
    plt.show()

Exponential (Skala = 1,0, Größe = Keine): Exponentialverteilung

lam = 0.1   #0 pro Minute.Kommt einmal vor.
x = rd.exponential(1./lam, size=20)
print x

result

[ 11.2642272   41.01507264  11.5756986   27.10318556  10.7079342
   0.17961819  24.49974467   6.46388826   9.69390641   2.85354527
   0.55508868   4.04772073  24.60029857  23.10866     19.83649067
  12.12219301  10.24395203   0.16056754   8.9401544    8.86083473]

Gibt eine Zufallszahl zurück, die aus einer Exponentialverteilung mit dem Parameter lam generiert wurde. lam ist ein Parameter, der die durchschnittliche Häufigkeit angibt, die in einer Zeiteinheit auftritt. Wenn Sie auf Exponential setzen, stellen Sie die Umkehrung von Lam auf Skalierung ein. Exponential gibt eine Zufallszahl zurück, die angibt, wie viele Stunden für das nächste Auftreten eines Ereignisses benötigt wurden, das durchschnittlich in einer Zeiteinheit auftritt.

Mit anderen Worten, wenn es ein Ereignis gibt, das durchschnittlich 0,1 Mal in 1 Minute auftritt, zeigt eine 3 an, dass es 3 Minuten später aufgetreten ist. Die folgende Grafik ist ein Histogramm der Zufallszahlen, die aus der Exponentialverteilung bei lam = 0,1 generiert wurden.

lam = 0.1  #0 pro Minute.Kommt einmal vor.
x = rd.exponential(1./lam, size=10000)
plt.hist(x, 100)

Referenzierte Site

numpy Referenzseite http://docs.scipy.org/doc/numpy/reference/routines.random.html