Tutoriel : générateur de nombres aléatoires avec NumPy

Le module random de NumPy propose une suite de fonctions fondées sur la génération de nombres pseudo-aléatoires. Aléatoire signifie qu’on ne peut pas le prédire logiquement.

np.random.seed() Fonction

Dans cet exemple, vous allez simuler un lancer de pièce. Vous utiliserez la fonction np.random(), qui tire un nombre entre 0 et 1, tous les nombres de cet intervalle étant équiprobables.

Si le nombre tiré est inférieur à 0,5 (ce qui a 50 % de chances d’arriver), on dit pile, sinon face. Ce type d’expérience où l’issue est soit Vrai (pile) soit Faux (face) est appelé un essai de Bernoulli.

Les nombres pseudo-aléatoires sont générés à partir d’un entier appelé graine (seed), puis produits en succession. La même graine donne la même séquence de nombres aléatoires, d’où le terme « pseudo ». Si vous souhaitez un code reproductible, il est recommandé d’initialiser le générateur avec la fonction np.random.seed().

Pour réaliser les lancers, vous importez NumPy, initialisez la graine, puis tirez quatre nombres aléatoires. Vous pouvez préciser combien de nombres vous souhaitez via le paramètre size.

import numpy as np
np.random.seed(42)
random_numbers = np.random.random(size=4)
random_numbers
Propulsé par

array([0.3745012, 0.95071431, 0.73199394, 0.59865848])
Propulsé par

Le premier nombre est inférieur à 0,5, donc c’est pile, tandis que les trois autres sont face. Vous pouvez le montrer explicitement avec l’opérateur « inférieur à », qui renvoie un tableau de booléens : True pour pile et False pour face.

heads = random_numbers < 0.5
heads
Propulsé par

array([True, False, False, False], dtype=bool)
Propulsé par

Enfin, vous pouvez calculer le nombre de piles en sommant le tableau booléen heads, car en contexte numérique, Python traite True comme un et False comme zéro.

np.sum(heads)
Propulsé par

1
Propulsé par

Simuler quatre lancers de pièce aléatoires

Dans l’exemple suivant, nous voulons connaître la probabilité d’obtenir quatre piles si l’on répète ces quatre lancers encore et encore. Nous pouvons le faire avec une boucle for.

Nous initialisons d’abord le compteur à zéro. Nous effectuons ensuite 10 000 répétitions d’essais de quatre lancers. Si un essai donné affiche quatre piles, nous incrémentons le compteur.

Quelle est donc la probabilité d’obtenir quatre piles d’affilée ? C’est le nombre de fois où vous avez obtenu quatre piles, divisé par le nombre total d’essais. Le résultat est d’environ 0,06.

n_all_heads = 0

# Initialiser le nombre d'essais avec 4 piles
for _ in range(10000):
         heads = np.random.random(size=4) < 0.5
         n_heads = np.sum(heads)
         if n_heads == 4:
             n_all_heads += 1

n_all_heads / 10000
Propulsé par

0.0621
Propulsé par

Exemple interactif de génération de nombres aléatoires

Dans cet exemple, nous allons générer un grand nombre de valeurs aléatoires entre zéro et un, puis tracer un histogramme des résultats. Si les nombres sont réellement aléatoires, toutes les barres de l’histogramme devraient avoir une hauteur (à peu près) identique.

Pour cet exemple, vous devrez :

• Initialiser le générateur avec np.random.seed en utilisant la graine 42.
• Initialiser un tableau vide, random_numbers, de 100 000 éléments pour stocker les nombres aléatoires. Utilisez np.empty(100000).
• Écrire une boucle for pour tirer 100 000 nombres avec np.random.random() et les stocker dans le tableau random_numbers. Pour cela, itérez sur range(100000).
• Tracer un histogramme de random_numbers. Il n’est pas nécessaire d’étiqueter les axes ici, car nous vérifions simplement le générateur.

# Initialiser le générateur de nombres aléatoires
np.random.seed(42)

# Initialiser le tableau des nombres aléatoires : random_numbers
random_numbers = np.empty(100000)

# Générer des nombres aléatoires en bouclant sur range(100000)
for i in range(100000):
    random_numbers[i] = np.random.random()

# Tracer un histogramme
_ = plt.hist(random_numbers)

# Afficher le graphique
plt.show()
Propulsé par

Lorsque nous exécutons ce code, il produit le résultat suivant :

Essayez par vous-même.

Pour en savoir plus sur les générateurs de nombres aléatoires et les « hacker statistics », regardez cette vidéo issue de notre cours Statistical Thinking in Python (Part 1).

Ce contenu est tiré du cours Statistical Thinking in Python (Part 1) de DataCamp, par Justin Bois.