Tutorial: willekeurigegetallengenerator met NumPy

De random-module van NumPy is een reeks functies gebaseerd op pseudowillekeurige getalgeneratie. Willekeurig betekent iets dat je logisch niet kunt voorspellen.

np.random.seed()-functie

In dit voorbeeld simuleer je een muntworp. Je gebruikt de functie np.random(), die een getal tussen 0 en 1 trekt, waarbij alle getallen in dit interval even waarschijnlijk zijn.

Als het getrokken getal kleiner is dan 0,5, wat een kans van 50% heeft, noem je het kop, anders munt. Dit type uitkomst, waarbij resultaten ofwel True (kop) of False (munt) zijn, wordt een Bernoulli-experiment genoemd.

Een pseudowillekeurige getallengenerator werkt door te beginnen met een geheel getal, de zogenaamde seed, en vervolgens opeenvolgende getallen te genereren. Dezelfde seed geeft dezelfde reeks willekeurige getallen, vandaar de naam "pseudo"-willekeurige getalgeneratie. Als je reproduceerbare code wilt, is het goed om de willekeurigegetallengenerator te seeden met de functie np.random.seed().

Voor de muntworpen importeer je NumPy, seed je de generator en trek je vervolgens vier willekeurige getallen. Je kunt met de keyword size aangeven hoeveel willekeurige getallen je wilt.

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

array([0.3745012, 0.95071431, 0.73199394, 0.59865848])

Het eerste getal is kleiner dan 0,5, dus dat is kop, terwijl de overige drie munt zijn. Je kunt dit expliciet laten zien met de kleiner-dan-bewerking, die je een array met booleans geeft: True voor kop en False voor munt.

heads = random_numbers < 0.5
heads

array([True, False, False, False], dtype=bool)

Tot slot kun je het aantal keer kop berekenen door de boolean-array heads op te tellen, omdat Python in numerieke context True als één en False als nul behandelt.

np.sum(heads)

1

Vier willekeurige muntworpen simuleren

In het volgende voorbeeld willen we de kans weten op vier keer kop als we de vier worpen steeds opnieuw zouden herhalen. Dat kan met een for-lus.

We initialiseren eerst de teller op nul. Vervolgens herhalen we het experiment met vier worpen 10.000 keer. Als een bepaalde proef vier keer kop oplevert, verhogen we de teller.

Wat is dus de kans op vier keer kop? Dat is het aantal keer dat je vier keer kop kreeg, gedeeld door het totale aantal proeven. Het resultaat is ongeveer 0,06.

n_all_heads = 0

# Initialize number of 4-heads trials
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

0.0621

Interactief voorbeeld van willekeurige getallen genereren

In dit voorbeeld genereren we veel willekeurige getallen tussen nul en één en maken we vervolgens een histogram van de resultaten. Als de getallen echt willekeurig zijn, zouden alle balken in het histogram (bijna) even hoog moeten zijn.

Voor dit voorbeeld moet je het volgende doen:

• Seed de willekeurigegetallengenerator met np.random.seed en gebruik de seed 42.
• Initialiseer een lege array, random_numbers, met 100.000 items om de willekeurige getallen in op te slaan. Gebruik hiervoor np.empty(100000).
• Schrijf een for-lus om 100.000 willekeurige getallen te trekken met np.random.random() en sla ze op in de array random_numbers. Loop hiervoor over range(100000).
• Maak een histogram van random_numbers. Het is niet nodig de assen te labelen, omdat we alleen de generator controleren.

# Seed the random number generator
np.random.seed(42)

# Initialize random numbers: random_numbers
random_numbers = np.empty(100000)

# Generate random numbers by looping over range(100000)
for i in range(100000):
    random_numbers[i] = np.random.random()

# Plot a histogram
_ = plt.hist(random_numbers)

# Show the plot
plt.show()

Als we de bovenstaande code uitvoeren, levert dat het volgende resultaat op:

Probeer het zelf.

Wil je meer leren over willekeurigegetallengeneratoren en hackerstatistiek? Bekijk dan deze video uit onze cursus Statistical Thinking in Python (Part 1).

Deze content is afkomstig uit DataCamps cursus Statistical Thinking in Python (Part 1) door Justin Bois.