[python] Mémorandum de génération aléatoire

Chaque fois que j'essaie de générer des nombres aléatoires, je ne me souviens plus quelle fonction utiliser, j'ai donc rassemblé un mémorandum des fonctions de génération de nombres aléatoires qui sont susceptibles d'être utilisées fréquemment.

En particulier, les nombres aléatoires générés à partir des diverses distributions de probabilité dans la seconde moitié sont représentés avec des graphiques et des images, donc je pense que cela sera utile pour comprendre la distribution de probabilité elle-même. En particulier, je m'inquiétais de la distribution du chi carré car je ne connaissais pas l'image dans le passé, alors j'ai essayé de l'expliquer intuitivement.

Ci-dessous, il est décrit en supposant que les bibliothèques suivantes sont importées.

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

Numéro aléatoire du système de distribution uniforme

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

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

result

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

Générer une distribution uniforme de [0, 1). Le nombre d'éléments dans la dimension du nombre aléatoire généré peut être spécifié dans l'argument. Dans l'exemple ci-dessus, il s'agit de 2 lignes et 3 colonnes. Génère un nombre aléatoire sans argument.

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]]

Génère des nombres aléatoires générés à partir d'une distribution normale avec une moyenne de 0 et un écart type de 1. Le nombre d'éléments dans la dimension du nombre aléatoire généré peut être spécifié dans l'argument. Dans l'exemple ci-dessus, il s'agit de 2 lignes et 4 colonnes. Génère un nombre aléatoire sans argument. Si vous voulez spécifier la moyenne et l'écart type, écrivez comme 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"Math", u"Science", u"société", u"langue nationale", u"Anglais"])

for l in li[x]:
    print l

result

[2 0 1 0 0 0 1 3 1 4]
société
Math
Science
Math
Math
Math
Science
langue nationale
Science
Anglais

Génère un nombre aléatoire entier généré à partir de la distribution uniforme discrète dans la plage spécifiée par l'argument. haut et la taille peuvent être omis. Notez que si haut n'est pas omis, une plage de [0, faible) est définie, et si haute est décrite, une plage de [faible, élevé) est définie, et les deux n'incluent pas la valeur limite supérieure.

Ceci est utile lorsque vous souhaitez extraire aléatoirement certains éléments d'un certain tableau.

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 de lancer les dés 100 fois
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]

Comme randint (), il génère un nombre aléatoire entier généré à partir de la distribution uniforme discrète dans la plage spécifiée par l'argument. haut et la taille peuvent être omis. La principale différence réside dans la plage, si high n'est pas omis, la plage est définie sur [1, low], si high est décrit, la plage est définie sur [low, high] et seul low est spécifié comme "y compris la limite supérieure". Où l'ajustement du boîtier est "1".

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]]

Comme le titre l'indique, il existe quatre types, http://stackoverflow.com/questions/18829185/difference-between-various-numpy-random-functions Selon, ils sont tous identiques (à part random_sample, il y a des alias). Que diable (rires) La différence avec rand () est que la façon de spécifier les arguments est que ceux-ci sont spécifiés par des taples, mais rand () est le moyen de spécifier qu'il y a plusieurs arguments eux-mêmes.

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

x1=rd.choice(5, 5, replace=False )     # 0-Équivaut au tri 4
print x1

x2=rd.choice(5, 5, p=[0.1,0.1,0.1,0.1,0.6]) #Forte probabilité d'obtenir 4
print x2

result

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

La structure de l'argument de choix est choice (a, size = None, replace = True, p = None). a représente la sélection aléatoire de la plage (a). Génère le nombre de nombres aléatoires spécifié par taille. Bien que le remplacement soit caractéristique, il est considéré comme échantillonné à partir de la plage (a), mais si True est spécifié, un nombre aléatoire sera généré sans renvoyer le nombre extrait. La même chose n'est pas deux fois. Par conséquent, si la valeur de a est inférieure à size, une erreur se produira. Bien que p soit également caractéristique, vous pouvez spécifier la probabilité d'occurrence de chaque nombre au lieu d'un nombre aléatoire uniforme. Par conséquent, si les tailles de a et p ne sont pas les mêmes, une erreur se produira.

Les autres nombres aléatoires jusqu'à présent sont retournés par la liste standard de python, mais cela renvoie la valeur de retour par ndarray de numpy.

shuffle(x) ###

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

result

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

Une fonction qui mélange aléatoirement l'ordre d'un tableau. Notez qu'il modifie le tableau lui-même donné en argument, plutôt que de le renvoyer en tant que valeur de retour.

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

Si une variable de type int est spécifiée comme argument, range (a) est généré en interne et trié de manière aléatoire. Si list est spécifié comme argument, les éléments sont triés de manière aléatoire. La valeur de list n'est pas une valeur numérique mais peut être une liste telle qu'une chaîne de caractères.

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]

Génère des nombres aléatoires générés à partir d'une distribution uniforme. La différence avec la fonction de génération de nombres aléatoires uniformément distribuée expliquée jusqu'à présent est que la plage peut être spécifiée. La structure de l'argument est (low = 0.0, high = 1.0, size = None) et une section semi-ouverte avec un sommet ouvert tel que [low, high).

Nombre aléatoire du système de modèle de distribution de probabilité

binomial (n, p, size = None): distribution binaire

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]

Génère un nombre aléatoire généré à partir de la distribution binomiale lorsque l'essai de probabilité de succès p est effectué n fois. Ce qui suit peut être considéré comme un histogramme lorsque la probabilité de 0,5 tirage au sort est effectuée 30 fois et le nombre de fois est noté, ce qui est effectué 3000 fois.

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

poisson (lam = 1.0, size = None): distribution de Poisson

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]

Un nombre aléatoire est généré à partir de la distribution de Poisson qui se produit lam fois par unité de temps. En prenant le taux de clics d'une certaine publicité comme exemple, il est appliqué au cas où la publicité est cliquée 30 fois par heure.

Les éléments suivants peuvent être considérés comme un histogramme lorsqu'une moyenne de 5 clics par heure est tentée 1 000 fois (= 1 000 heures de données sont prises).

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

hypergéométrique (ngood, nbad, nsample, size = None): Distribution hypergéométrique

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

Génère un nombre aléatoire généré à partir d'une distribution supergéométrique. Par exemple, il n'y a pas de bons produits et nbad produits défectueux, et le nombre de bons produits qui peuvent être retirés lorsque nsamp pièces sont extraites par l'enquête sur le taux de défauts est retourné.

Le graphique ci-dessous montre le nombre de bons produits obtenus en échantillonnant 20 produits alors qu'il y a 190 bons produits et 10 produits défectueux (soit un taux de défectueux de 5%) dans une boîte de collecte contenant 200 produits. Il peut être considéré comme un histogramme des données lorsque cela est fait pour 3000 boîtes de collecte (qui contiennent exactement le même nombre de produits bons et défectueux).

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

géométrique (p, taille = Aucun): Distribution géométrique

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]

Générez un nombre aléatoire généré à partir de la distribution géométrique. Il renvoie un nombre aléatoire de fois lorsque l'essai de probabilité de succès p est répété jusqu'à ce qu'il réussisse.

Le graphique ci-dessous répète l'essai avec une probabilité de succès de 1% jusqu'à ce qu'il réussisse, et note le nombre de fois jusqu'à ce qu'il réussisse. On considère que les données répétées 1000 fois ont été transformées en histogramme.

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

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

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]

Il génère des nombres aléatoires générés à partir de la distribution normale, qui est la voie royale de la distribution de probabilité. loc est la moyenne et l'échelle est l'écart type. Voici l'histogramme.

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

En passant, le nombre aléatoire généré à partir de la distribution du chi carré introduite ensuite peut être créé à partir de la combinaison des nombres aléatoires générés à partir de cette distribution normale et du carré.

#Moyenne 0,Générer un nombre aléatoire généré à partir d'une distribution normale avec un écart type de 1 et mettre sa valeur au carré
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

#L'ajout de deux nombres aléatoires générés à partir de la distribution normale au carré donne une distribution chi-carré avec un degré de liberté (graphique bleu).
plt.hist(x1+x2,20, color='b')
plt.show()
#De plus, si vous en ajoutez trois, la distribution du chi carré avec 2 degrés de liberté (graphique vert)
plt.hist(x1+x2+x3,20, color='g')
plt.show()
#Ajoutez 6 de plus à la distribution du chi carré avec 5 degrés de liberté (graphique rouge)
plt.hist(x1+x2+x3+x4+x5+x6,20, color='r')
plt.show()

chisquare (df, size = None): distribution du chi carré

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]

Renvoie un nombre aléatoire généré à partir d'une distribution chi carré avec df degrés de liberté. Comme mentionné dans la section précédente, la distribution du chi carré est une distribution qui suit le carré des nombres aléatoires générés à partir de la distribution normale standard et de leur somme.

#2 degrés de liberté, 5,Un histogramme de nombres aléatoires généré par une distribution du chi carré selon 20
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): distribution F

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]

Renvoie un nombre aléatoire généré à partir d'une distribution F avec deux degrés de liberté dfnum et dfden. Cette distribution F est une distribution de probabilité composée de variables de probabilité qui suivent deux distributions du chi carré indépendantes dans la molécule et le dénominateur (chacune divisée par le degré de liberté). La distribution du chi carré peut être considérée comme une variance dans le sens où elle est normalisée et au carré, elle est donc utilisée pour tester que les deux variances sont identiques.

Le graphique ci-dessous est un histogramme de nombres aléatoires générés à partir d'une distribution F avec des degrés de liberté (1,4), (5,7), (10,10), (40,50), respectivement.

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

exponentielle (échelle = 1.0, taille = Aucune): Distribution exponentielle

lam = 0.1   #0 par minute.Se produit une fois.
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]

Renvoie un nombre aléatoire généré à partir d'une distribution exponentielle avec le paramètre lam. lam est un paramètre qui indique le nombre moyen de fois qui se produit dans une unité de temps. Lors du réglage sur exponentiel, réglez l'inverse de lam à l'échelle. exponential renvoie un nombre aléatoire indiquant le nombre d'heures d'unité qu'il a fallu pour la prochaine occurrence d'un événement qui se produit une moyenne de lam fois dans une unité de temps.

En d'autres termes, s'il y a un événement qui se produit 0,1 fois en moyenne en 1 minute, et s'il est 3, cela signifie qu'il s'est produit 3 minutes plus tard. Le graphique ci-dessous est un histogramme des nombres aléatoires générés à partir de la distribution exponentielle lorsque lam = 0,1.

lam = 0.1  #0 par minute.Se produit une fois.
x = rd.exponential(1./lam, size=10000)
plt.hist(x, 100)

Site référencé

site de référence numpy http://docs.scipy.org/doc/numpy/reference/routines.random.html