TechVidvan

Random Sampling in NumPy

by

Random sampling is a fundamental idea in statistics and data analysis. It enables us to choose a subset of data points from a larger dataset without any particular pattern or bias for numerous applications, including statistical inference, hypothesis testing, and machine learning.

This article will explain random sampling, why it’s crucial, and how to implement it using NumPy, a well-known Python package for numerical operations.

What is Random Sampling?

The act of choosing a random subset of data points from a particular dataset is known as random sampling. The fundamental premise is that every data point in the dataset has an equal chance of being chosen and that neither a systematic nor an unconscious bias affects the choice. Because it allows us to draw conclusions about a wider population from a representative sample, random sampling is crucial.

Why Use Random Sampling?

Random sampling offers several advantages:

  • Statistical validity: Random sampling increases the probability of obtaining a representative sample, which enhances the validity of any statistical analysis or inference made from the sample.
  • Reduced bias: Random sampling minimizes the risk of introducing bias into the analysis. Non-random sampling methods, such as convenience sampling, can lead to skewed results.
  • Generalizability: Random samples are more likely to generalize well to the entire population, which is crucial in fields such as polling, market research, and quality control.

Implementing Random Sampling with NumPy

NumPy is a powerful Python library for numerical computations. It provides convenient functions for generating random numbers and performing random sampling. Let’s explore how to implement random sampling in 1D, 2D, and multidimensional arrays using NumPy.

Random Sampling in 1D Arrays

To perform random sampling in a 1D NumPy array, you can use the numpy.random.choice function. Here’s an example:

import numpy as np

# Create a 1D array
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Perform random sampling
sample = np.random.choice(data, size=5, replace=False)

print("Randomly sampled 1D array:", sample)

In this example, np.random.choice selects 5 random elements from the data array without replacement, ensuring that each element is selected only once.

Output:

Randomly sampled 1D array: [ 6 9 1 4 10]

Random Sampling in 2D Arrays

Random sampling in 2D arrays is quite similar. You can use the same np.random.choice function, but specify the axis along which you want to sample. Here’s an example:

import numpy as np

# Create a 2D array
data = np.array([[1, 2, 3],
                 [4, 5, 6],
                 [7, 8, 9]])

# Perform random sampling along rows
sampled_rows = np.random.choice(data.shape[0], size=2, replace=False)
sampled_data = data[sampled_rows, :]

print("Randomly sampled 2D array (rows):")
print(sampled_data)

In this example, we first select two random row indices and then extract those rows from the original 2D array.

Output:

Randomly sampled 2D array (rows):
[[7 8 9]
[4 5 6]]

Random Sampling in Multidimensional Arrays

For multidimensional arrays, the concept remains the same. You can specify the axis along which you want to perform random sampling. Here’s an example:

import numpy as np

# Create a 3D array
data = np.array([[[1, 2], [3, 4]],
                 [[5, 6], [7, 8]],
                 [[9, 10], [11, 12]]])

# Perform random sampling along the first dimension
sampled_data = np.random.choice(data.shape[0], size=2, replace=False)
sampled_data = data[sampled_data, :, :]

print("Randomly sampled 3D array (along the first dimension):")
print(sampled_data)

In this example, we randomly select two 2D arrays along the first dimension of the 3D array.

Output:

Randomly sampled 3D array (along the first dimension):
[[[ 5 6]
[ 7 8]]

[[ 1 2]
[ 3 4]]]

NumPy Random Sampling Methods-

NumPy provides various methods for generating random numbers and performing random sampling. In this section, we’ll elaborate on four methods for random sampling:

  • numpy.random_sample() method
  • numpy.ranf() method
  • numpy.random_integers() method
  • numpy.randint() method

1. numpy.random_sample()

The numpy.random_sample() method generates random floating-point numbers in the half-open interval [0.0, 1.0). It’s a convenient way to create random samples from a uniform distribution.

import numpy as np

# Generate 5 random numbers between 0.0 (inclusive) and 1.0 (exclusive)
random_samples = np.random.random_sample(5)
print("Random samples:", random_samples)

Expected Output (Note: Your output will vary due to randomness):
Random samples: [0.12345678 0.23456789 0.3456789 0.45678901 0.56789012]

2. numpy.ranf()

The numpy.ranf() method is an alias for numpy.random_sample(). It also generates random floating-point numbers in the half-open interval [0.0, 1.0).

import numpy as np

# Generate 5 random numbers using ranf()
random_samples = np.random.ranf(5)
print("Random samples:", random_samples)

Expected Output (Note: Your output will vary due to randomness):
Random samples: [0.12345678 0.23456789 0.3456789 0.45678901 0.56789012]

3. numpy.random_integers()

The numpy.random_integers() method generates random integers within a specified range. It includes both the lower and upper bounds of the range.

import numpy as np

# Generate 5 random integers between 1 and 10 (inclusive)
random_integers = np.random.random_integers(1, 10, 5)
print("Random integers:", random_integers)

Expected Output (Note: Your output will vary due to randomness):
Random integers: [ 5 7 10 1 4]

4. numpy.randint()

The numpy.randint() method is similar to numpy.random_integers() but provides a more flexible way to specify the range of random integers. It generates random integers within the half-open interval [low, high).

import numpy as np

# Generate 5 random integers between 1 (inclusive) and 10 (exclusive)
random_integers = np.random.randint(1, 10, 5)
print("Random integers:", random_integers)

Expected Output (Note: Your output will vary due to randomness):
Random integers: [7 6 3 1 9]

Conclusion

Drawing representative subsets from datasets requires the use of the random sampling approach. Implementing random sampling in many dimensions is simple by using NumPy’s robust random number-generating capabilities. NumPy offers the tools you need to ensure your samples are unbiased and statistically valid, whether you’re working with 1D, 2D, or multidimensional arrays. Making more precise inferences and utilising random sampling properly will help your data analysis be of higher calibre. Coding is fun!

Tags: