Online Robotics and STEM Club for Far East International Schools

1. Introduction: Why Random Numbers Matter in AI and Machine Learning

In data science, machine learning, and artificial intelligence, algorithms frequently work with large matrices containing thousands or millions of rows and columns. During model development, these massive matrices cannot remain empty; they often require initialization with random numbers.

Random values are essential for initializing model weights, generating synthetic data, splitting datasets, and running probabilistic simulations. However, working with random numbers introduces two fundamental engineering challenges:

1. Reproducibility: Ensuring that experiments and random number sequences can be replicated identically across different runs.
2. Performance (vectorization): Generating and manipulating millions of numbers at machine speed without slow Python loops.

2. The Modern Random Number Generator (default_rng)

NumPy provides a dedicated random number generation engine accessible via np.random.default_rng().

Calling this constructor initializes a generator object (conventionally named rng) that provides specialized methods for sampling from various statistical distributions:

• .integers(low, high, size) — draws random discrete integers from a specified range.
• .random(size) — generates random floating-point numbers uniformly distributed between 0.0 and 1.0.
• .normal(loc, scale, size) — draws numbers from a Gaussian (normal) distribution with a given mean and standard deviation.

3. Simulating Coin Flips with .integers()

To see random generation in action, we can simulate flipping a fair coin 100,000 times using discrete integers:

• Define 0 to represent Tails and 1 to represent Heads.
• Call rng.integers(0, 2, size=100000).
• Range rule: The first boundary (0) is inclusive; the upper boundary (2) is exclusive. Generated integers are strictly 0 and 1.

import numpy as np

# 1. Initializing the modern NumPy random generator object
rng = np.random.default_rng()

# 2. Simulating 100,000 coin flips (0 = Tails, 1 = Heads)
flips = rng.integers(0, 2, size=100000)

# 3. Calculating the mean probability of getting Heads
prob_heads = np.mean(flips)
print("Probability of Heads:", prob_heads)

Execution Walkthrough & Probability Analysis

• np.mean(flips) computes the average of zeros and ones—the observed probability of Heads.
• On one run the probability may be about 0.5008; on another about 0.49972.
• Because the generator draws values randomly, individual runs vary slightly, but across 100,000 trials results consistently converge near 50% Heads and 50% Tails.

4. Reproducibility in AI Experiments: The Role of the Seed

In scientific computing and machine learning research, randomness alone is not enough. Models must be evaluated repeatedly across development iterations. If training data or weight initializations change on every run, you cannot tell whether an improvement came from an algorithmic change or from random variation. Experiments must use the exact same sequence every time.

How the Seed Works

A seed sets the starting point for the random number generator’s algorithm. With a fixed seed, the algorithm always produces the same sequence:

# Initializing the generator with a fixed seed value (e.g., 43)
rng = np.random.default_rng(seed=43)

# Simulating 100,000 coin flips with the fixed seed
flips = rng.integers(0, 2, size=100000)
print("Run 1 Probability:", np.mean(flips))

# Re-initializing with the exact same seed
rng_repeat = np.random.default_rng(seed=43)
flips_repeat = rng_repeat.integers(0, 2, size=100000)
print("Run 2 Probability:", np.mean(flips_repeat))

Example output:

Run 1 Probability: 0.50238
Run 2 Probability: 0.50238

Passing seed=43 locks the generator so every subsequent run yields the same probability and the same sequence of numbers.

5. Performance Benchmark: Python Loops vs. NumPy Vectorization

Beyond generating numbers, computations on large datasets need high-speed execution. NumPy achieves this with vectorization, delegating array operations to optimized C-level routines.

import time

# Benchmark 1: Standard Python list using an explicit loop
raw_list = list(range(1000000))
start_time = time.time()
loop_result = [x + 5 for x in raw_list]
list_time = time.time() - start_time
print(f"Standard Python List Time: {list_time:.4f} seconds")

# Benchmark 2: NumPy ndarray using vectorization
np_array = np.arange(1000000)
start_time = time.time()
vectorized_result = np_array + 5
numpy_time = time.time() - start_time
print(f"NumPy Vectorized Time:     {numpy_time:.4f} seconds")

Measured results (approximate):

• Standard Python list with loop: ~0.1907 seconds
• NumPy vectorized array: ~0.0160 seconds

Vectorization applies operations across the whole array in parallel and finishes in a fraction of the time of an interpreted loop.