Working with Random Numbers in Numpy
Working with Random Numbers in Numpy
Random is a module in the Numpy library for providing random numerical data in any required data structure.
It contains simple functions/methods to generate random numbers, permutations and probability distributions. In this tutorial, we will understand how to use these functions and create random data as per our needs.
These features are based on PRNG(Pseudo Random Number Generation) Algorithms. To suffice, the PRN generator uses mathematical formulas to produce sequence of random numbers using an arbitrary seed state. This helps to reproduce the same numbers at one's convenience.
Let's begin by importing numpy.
import numpy as np
Simple Random Functions
Let's go over these functions one by one:
numpy.random.rand()
- This function allows random numbers generation in a desired shape (Provided in the argument).
- Syntax: numpy.random.rand().
- This will typically return values from a uniform distribution over 0,1.
Uniform Distribution: When the probability of each value is equally likely, example, rolling a fair die.
- If no argument is provided, the function will return a single float value.
a = np.random.rand()
b = np.random.rand(2)
print(a, ",", b)
0.3224876833345295 , [0.80038351 0.02511512]
#creating an array of dimensions (4[2,2])
a = np.random.rand(4,2,2)
a
array([[[0.5709071 , 0.23116103],
[0.17869279, 0.03264607]],
[[0.38270662, 0.99443131],
[0.60835673, 0.16401943]],
[[0.30376811, 0.7839127 ],
[0.51879298, 0.98232092]],
[[0.68055995, 0.36071315],
[0.793239 , 0.20790045]]])
numpy.random.randn()
randn()
is simillar torand()
and provides an array of the mentioned dimensions except that, this function returns random floats sampled from a Standard Normal Distribution.

-
The Standard Normal Distribution is the Gaussian(Normal) Distribution with mean 0 and variance 1.
-
In any case the argument provided are float, they are first converted to int.
a = np.random.randn()
b = np.random.randn(2,2)
print("a = ", a, ",\n"," b = ", b)
a = -0.2597162279610976 ,
b = [[ 0.26918118 -0.72787076]
[ 0.11213333 1.33860462]]
numpy.random.randint()
- This function takes in a
low
and ahigh
argument & returns random integers from the half-open interval. i.e[low, high)
low(inclusive), high (exclusive) - You can mention size of required array in the
size
argument.
a = np.random.randint(3)
b = np.random.randint(low=2,high=7, size=3)
print("a = ", a, ",\n"," b = ", b)
a = 1 ,
b = [4 4 2]
- If high is none, then the result will range within [0, low).
a = np.random.randint(1, size=8)
a
array([0, 0, 0, 0, 0, 0, 0, 0])
numpy.random.random()
& random_sample()
-
Above mentioned both functions have the same functionality and can be used inter-changeably.
-
These functions return random floats in the half open interval's continous uniform distribution of
[0.0, 1.0)
. -
You can specify the
size
(optional) argument to return an array of a specific size.
a = np.random.random()
a
0.4502639286171949
b = np.random.random_sample(size=8)
b
array([0.78564775, 0.12364401, 0.09253097, 0.20851597, 0.66741015,
0.19139018, 0.03421576, 0.51810702])
Note: Along with these two, numpy.random.sample()
and numpy.random.ranf()
and return the same results.
numpy.random.choice()
-
The
choice
function generates a random sample from a given 1-D array ina
argument. -
You can use the
size
argument to mention the output shape. -
If for the input, an array is provided the values in the output come from this input array. But if an integer is provided for the input, random values are generated from
numpy.arange(input_int)
.
(You can check out the functionality of np.arange() here: https://numpy.org/doc/stable/reference/generated/numpy.arange.html?highlight=arange#numpy-arange)
a = np.random.choice(15,4)
a
array([1, 3, 5, 1])
b = np.random.choice(a, 2)
b
array([1, 3])
-
The
choice
function also provides thereplace:boolean
argument, which is True by default.
Which means that a value of input arraya
, can selected multiple times. -
The
p
argument ≡probabilities
associated with each entry ina
. i.e,
You can provide another argument stating the probability for selecting each item ina
.
Note: Make sure that the probabilites you provide for each entry in a
have the same size as a and sum upto 1.
a = np.random.choice(7, 4)
b = np.random.choice(a, 2, replace=False, p = [0.1, 0.1, 0.5, 0.3])
b
array([6, 6])
numpy.random.bytes()
-
This function simply returns random bytes of the size mentioned in the argument.
-
random.bytes(length)
-
This can especially be used to generate API keys and passwords.
a = np.random.bytes(5)
b = np.random.bytes(50)
print("a = ", a, ",\n"," b = ", b)
a = b'\xde\x87\xa2\xfb)' ,
b = b'\x10\x01>-\xae\x08WY\xfc\x00\x99\x96\x83Q)&\xbf3f\xf1I\xe8\x99\xd3\xf2t\xf5\xdb\x8e\r>\xc5\xaee\x80[CM\t4\xc9\x19L\xa6\xd2\xd33|\x8d\x99'
Random Distributions
Random
provides a myriad of methods to access probability distributions. You can access the whole list of methods provided by random here: https://numpy.org/doc/1.16/reference/routines.random.html#distributions
Let's look at a few examples:
Normal Distribution
-
numpy.random.normal(loc, scale, size)
-
Like the name suggests, this function will return random samples from a normal (Gaussian) Distribution.
-
loc
: Mean,scale
: Std Deviation,size
: Output shape -
Read more about Normal Distributions
m , sd = 2 ,0.2
n = np.random.normal(m, sd, 1000)
Using Seaborn to plot our distribution:
import matplotlib.pyplot as plt
import seaborn as sns
sns.histplot(n, kde=True);
Binomial Distribution
numpy.random.binomial(n,p,size)
n
: Number of Trials at a timep
: Probability of Success- Read more about Binomial Distribution
Let's create a distribution of number of heads in a coin tossed a 100 times with probability = 0.5.
b = np.random.binomial(n = 2, p = 0.5, size=100)
b
array([1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 2, 0, 2, 0, 1, 1, 1, 1, 0,
2, 1, 1, 0, 1, 1, 2, 2, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 1, 1, 2, 0, 1, 2, 1, 1, 0, 2, 1, 0, 1, 0, 1, 1, 0, 1, 1, 2,
1, 0, 1, 1, 2, 1, 2, 1, 0, 2, 2, 1, 2, 0, 0, 0, 1, 0, 2, 2, 1, 1,
0, 1, 0, 1, 1, 2, 2, 0, 1, 1, 0, 1])
Similarly, we can create data for a dice with each digit having a probability of 1/6, being tossed a 100 times.
b = np.random.binomial(n=6, p=1/6, size=100)
b
array([1, 0, 1, 1, 1, 2, 1, 1, 2, 3, 1, 1, 1, 0, 3, 2, 2, 3, 0, 1, 2, 1,
0, 0, 0, 2, 0, 1, 0, 3, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 2, 1, 1,
3, 2, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 2, 1, 0, 3, 1, 2, 2, 1, 2,
2, 0, 2, 0, 1, 1, 1, 0, 0, 2, 3, 2, 0, 1, 0, 3, 1, 0, 1, 2, 3, 2,
2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 3, 0])
Uniform Distribution
-
numpy.random.uniform(low, high, size)
-
This function draws samples from a half open interval of the uniform distribution between the
low
andhigh
argument. i.e[low, high)
. -
Hence, any value btw low and high, is equally likely to be chosen or
-
By default
low
is 0 andhigh
is 1. -
Read more about Uniform Distribution
u = np.random.uniform(size = 100)
sns.histplot(u);
# Execute this to save new versions of the notebook
jovian.commit(project="numpy-random-module")
[jovian] Detected Colab notebook...
[jovian] Uploading colab notebook to Jovian...
Committed successfully! https://jovian.ai/himani007/numpy-random-module
Random Generator
RandomState
numpy.random.RandomState(seed)
- This specific function is a container which provides access to a wide variety of probability distributions using the Mersenne Twister PRNG.
- In simple words, RandomState uses the Mersenne Twister Pseudo Random Number Generator within just like
Random
but the only difference being, thatRandomState
provides a much larger number of probability distributions to choose from.
You can access the entire list of Methods provided by RandomState
here: https://numpy.org/doc/1.16/reference/generated/numpy.random.RandomState.html#numpy-random-randomstate
Seed
np.random.seed(seed)
- The random number generator needs a number to start with, which we fix using
seed
. - This method is used when we want to reproduce the same set of numbers.
- We can initialize a seed to generate a random set of numbers, and with the same seed value, a simillar set of numbers will be generated everytime.
np.random.seed(10)
a = np.random.rand()
a
0.771320643266746
np.random.seed(10)
b = np.random.rand()
print(a,b)
0.771320643266746 0.771320643266746
Typically a seed is used when we want to produce the same random numbers throughout the notebook. So after declaring the seed once in the beginning, you can expect different random number sequences accross the notebook, yet the same sequences everytime you re-run your notebook.
Permutations
The Random module provides the following functions for permutations:
Shuffle
numpy.random.shuffle(x)
, wherex
: Array- This function is used to shuffle the array provided in the argument.
arr = np.random.randint(8, size=5)
arr
array([0, 3, 2, 1, 4])
np.random.shuffle(arr)
arr
array([1, 2, 4, 3, 0])
Note: In case of a multidimensional array, the arrays are shuffled along the first axis.
Permutation
-
numpy.random.permutation(x)
, wherex
: int or array. -
This function can be used as shuffle for rearranging or if
x
is an integer, then the function will first callnp.arange(x)
, and then shuffle the array.
np.random.permutation(8)
array([7, 5, 4, 6, 2, 3, 0, 1])
a = np.random.permutation(8)
np.random.permutation(a)
array([4, 6, 7, 1, 2, 5, 0, 3])
Conclusion
Random module is suitable when there is need for a huge number of random numbers especially when the same sequence is needed repeatedly. In this tutorial we learned examples on numpy.random's:
- rand()
- randn()
- randint()
- random(), sample()
- choice()
- bytes()
References
jovian.commit(project="numpy-random-module")
[jovian] Detected Colab notebook...
[jovian] Uploading colab notebook to Jovian...
Committed successfully! https://jovian.ai/himani007/numpy-random-module