Name: Tremplin Numérique
Price range: $$$

Sommaire

Résumé

Créez un objet rng avec np.random.default_rng(), vous pouvez le générer pour des résultats reproductibles.
Vous pouvez prélever des échantillons à partir de distributions de probabilité, notamment des distributions binomiales et normales.
Vous pouvez mélanger les tableaux sur place avec rng.shuffle().

Que vous simuliez des distributions de probabilité ou que vous souhaitiez simplement un nombre aléatoire, c'est facile à faire avec la bibliothèque NumPy de Python.

Création du générateur de nombres aléatoires

Pour pouvoir générer des nombres aléatoires avec NumPy, vous devez créer le générateur de nombres aléatoires. Vous pouvez le faire après avoir importé la bibliothèque avec une simple commande :

        import numpy as np
rng = np.random.default_rng()

N'oubliez pas de mettre les parenthèses à la fin. Cela créera un objet générateur de nombres aléatoires. Vous pouvez également amorcer le générateur aléatoire. Cela signifie que la séquence de nombres aléatoires utilisant cette version prédéfinie sera reproductible. Si vous ne fournissez pas de graine, NumPy utilisera à la place la source aléatoire par défaut de votre système d'exploitation.

Pour créer un objet générateur de nombres aléatoires prédéfinis avec le nombre 42 comme graine :

        
seeded_rng = np.random.default_rng(42)

Générer des nombres aléatoires

Pour générer un nombre aléatoire à partir de votre générateur de nombres aléatoires nouvellement créé, utilisez simplement la méthode aléatoire :

        rng.random()

Pour créer un tableau de nombres aléatoires, indiquez la longueur du tableau souhaitée. Pour créer un tableau de 10 nombres aléatoires :

        rng.random(10)

Puisque NumPy fonctionne sur des tableaux multidimensionnels, vous pouvez l'utiliser pour créer des tableaux de nombres aléatoires. Utilisez simplement le nombre de lignes et le nombre de colonnes, séparés par une colonne. Pour créer un tableau NumPy avec trois lignes et cinq colonnes :

        A = rng.random((3,5))

Générer des nombres aléatoires à partir de la distribution binomiale

L'une des raisons pour lesquelles NumPy est si apprécié pour l'analyse de données est qu'il est facile de générer des nombres aléatoires pour la simulation.

Vous pouvez générer des nombres aléatoires à partir de distributions de probabilité spécifiques. La distribution binomiale est peut-être la distribution discrète la plus connue, qui représente le nombre de réussites dans n essais.

Vous pouvez générer des nombres aléatoires à partir de la distribution binomiale avec la méthode binomiale.

Nous pouvons simuler le fait de lancer une pièce de monnaie dix fois. Puisqu’une pièce équitable a deux faces différentes, pile et face, nous devrions avoir 50 % de chances d’obtenir pile ou face.

        rng.binomial(10,0.5)

Cela renverra le nombre de succès sur 10 lancers de pièces. Dans ce contexte, « succès » désigne le nombre de pile ou face sur 10 lancers de pièces. Le nombre de réussites renvoyées par le générateur de nombres aléatoires sera généralement d'au moins cinq. Vous pourriez penser que six ou sept succès sur 10 représentent plus que les 50 % que vous pourriez espérer pour une pièce équitable. Ces lancers de pièces s’excluent mutuellement, ce qui signifie qu’un tirage au sort n’affecte pas l’autre. Comment savoir si la pièce était vraiment juste ? Ce problème montre pourquoi il est difficile de le déterminer à partir de petits échantillons. Vous devrez le retourner encore davantage, selon la loi des grands nombres (comme expliqué dans les versions « faible » et « forte » de Wolfram MathWorld. Essayons d'augmenter le nombre de retournements. Essayons 50 :

        rng.binomial(50,0.5)

La valeur fluctuera, mais le nombre de réussites sera toujours proche de 25, soit la moitié de 50. Essayons 100 :

        rng.binomial(100,0.5)

Si vous continuez à augmenter le nombre d'essais, vous vous rapprocherez de plus en plus de 50 %, soit cinq réussites sur 10. Cela illustre le comportement limite de la probabilité, à savoir que vous vous rapprocherez de la probabilité théorique lorsque le nombre d'observations est très grand.

Vous pouvez également créer des listes d'essais binomiaux. Pour créer une liste des résultats de 10 essais de 10 tirages au sort chacun :

        a = rng.binomial(10,0.5,10)

Vous pouvez tracer un histogramme avec Seaborn :

        import seaborn as sns
sns.set_theme()
sns.displot(x=a)

Cela n'a l'air de rien, mais si vous continuez à augmenter le nombre d'observations et à en tracer des histogrammes, vous remarquerez que la distribution des succès ressemble davantage à la distribution normale, avec la fameuse courbe en forme de cloche.

Par exemple, essayez 100 observations :

        b = rng.binomial(10,.5,100)
sns.displot(x=b)

Et 1000 :

        c = rng.binomial(10,.5,100)
sns.displot(x=c)

Ceci est un exemple du théorème central limite (également expliqué par Wolfram MathWorld). Si vous regardez les moyennes de ces tableaux, vous remarquerez qu'ils convergent vers 5, ce qui signifie que la proportion de succès correspond aux 50 % de chances théoriques d'obtenir pile ou face, plus les tableaux sont grands :

a.mean()
b.mean()
c.mean()

Nombres aléatoires de la distribution normale

En plus de converger vers la distribution normale, vous pouvez générer des nombres aléatoires à partir de la distribution normale directement avec la méthode standard_normal.

Pour prendre un seul nombre aléatoire de la distribution normale :

        rng.standard_normal()

Cela imprimera un nombre aléatoire si vous êtes dans une session interactive. Vous pouvez également générer des tableaux de valeurs similaires à la méthode aléatoire. Par exemple, pour obtenir un tableau de distribution normal de 10 nombres ;

        a = rng.standard_normal(10)

Pour prouver que les valeurs proviennent bien de la distribution normale, vous pouvez générer un tableau de nombres plus grands et en tracer un histogramme. Essayons 100 nombres :

b = rng.standard_normal(100)
sns.displot(x=b)

Cela ressemble plus à la courbe normale. Essayons 1000 :

        
c = rng.standard_normal(1000)
sns.displot(x=b)

Vous pouvez également créer un tableau avec une moyenne et un écart type spécifiques en ajoutant et en multipliant des nombres au tableau. Pour créer un tableau normalement distribué de 100 nombres avec une moyenne de 4 et un écart type de 2 :

        a = 4 + 2 * rng.standard_normal(100)

Vous pouvez le vérifier en prenant la moyenne et l’écart type de cet échantillon.

        a.mean()
a.std()

Les résultats seront proches des valeurs que nous avons choisies.

Mélanger un tableau

Vous pouvez utiliser un générateur de nombres aléatoires NumPy pour mélanger un tableau sur place. Par exemple, pour mélanger un tableau de chaînes de noms de fruits :

        fruits = ('apples','oranges','bananas','grapefruits')
rng.shuffle(fruits)

Lorsque vous examinerez à nouveau le tableau, vous remarquerez que l'ordre des éléments est différent.

Vous pouvez utiliser cette fonction pour randomiser des éléments si vous développez un petit jeu. Vous pouvez représenter un jeu de cartes sous la forme d'un tableau Python et le mélanger automatiquement.

Avec NumPy, vous pouvez ajouter un peu d'aléatoire à vos programmes Python. Il est facile de générer des nombres aléatoires en créant un générateur de nombres aléatoires avec NumPy. f