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

binomial-compressor.png

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)

poisson.png

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)

hyper-compressor.png

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)

geo-compressor.png

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)

norm-compressor.png

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

sum_norm1-compressor.png sum_norm2-compressor.png sum_norm3-compressor.png

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

chisq1-compressor.png chisq2.png chisq3.png

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

f1-compressor.png f2-compressor.png f3-compressor.png f4-compressor.png

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)

exp-compressor.png

Site référencé

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

Recommended Posts

[python] Mémorandum de génération aléatoire
Génération de chaînes aléatoires (Python)
Mémorandum Python
Mémorandum Python 2
Mémorandum Python
mémorandum python
mémorandum python
Mémorandum Python
mémorandum python
Mémorandum Python
générateur de nombres aléatoires français avec python
Générateur de nombres premiers par Python
Génération de nombres pseudo aléatoires et échantillonnage aléatoire
Génération de nombres aléatoires entiers sans chevauchement (0-N-1)
Résumé de la génération de nombres aléatoires par Numpy
Mémorandum de base Python
Mémorandum de Python Pathlib
Mémorandum Python (algorithme)
# Génération de chaînes aléatoires
Mémorandum ABC [ABC157 C --Guess The Number] (Python)
Mémorandum Python [liens]
Blender 2.8, Python, mouvement de la caméra, spécification de couleur aléatoire
Génération de vecteurs de nombres aléatoires de haute dimension ~ Échantillonnage d'hypercube latin / Échantillonnage super carré latin ~
Variables de numérotation des mémorandums Python
mémorandum python (mise à jour séquentielle)
[Note] Création aléatoire?
Mémorandum Python (signet personnel)
Mémorandum de base Python partie 2
Premier nombre 2 en Python
Mémorandum @ Python OR Séminaire
mémorandum python super basique
python Remarque: que signifie définir une graine avec la génération de nombres aléatoires?
Forêt aléatoire équilibrée en python
Mémorandum Cisco _ configuration d'entrée avec Python
Module aléatoire de Numpy Génération aléatoire
Mémorandum ABC [ABC163 C --managementr] (Python)
fonction de mémorandum python pour débutant
Mémorandum @ Python OR Séminaire: matplotlib
[Python] Mémorandum sur l'évitement des erreurs SQLAlchemy
Mémorandum sur la corrélation [Python]
Mémorandum @ Python OR Séminaire: Pulp
Un mémorandum sur le simulacre de Python
Mémorandum @ Python OU Séminaire: Pandas
Choix aléatoire pondéré en python
Mémorandum @ Python OR Seminar: scikit-learn
mémorandum d'exécution parallèle / asynchrone python
Reconnaissance des nombres dans les images avec Python