## Weighted Random Sampling: An Overview

Random sampling is a technique used in statistics to select a subset of data from a population. In some cases, however, not all elements of the population are equally likely to be selected.

Weighted random sampling is a technique that accounts for this probability distribution. In this article, we will discuss two popular methods for weighted random sampling: `random.choices()`

and `numpy.random.choice()`

.

### Weighted Random Sampling with `random.choices()`

The `random.choices()`

function in Python’s `random`

module allows the user to choose a random element from a given sequence. It also allows the user to specify a weight for each element, which determines the likelihood of that element being selected.

For example, consider the following code:

```
import random
list = ['apple', 'banana', 'cherry', 'durian']
weights = [2, 1, 1, 5]
selection = random.choices(list, weights)
print(selection)
```

In this code, each element of `list`

has a weight assigned to it in the `weights`

list. The `selection`

variable will randomly choose an element from `list`

based on the weights provided.

In this case, `durian`

is 5 times more likely to be chosen than any of the other elements.

### Relative Weights to Choose Elements with Different Probability

The weights given to elements do not have to be whole numbers, nor do they need to add up to a specific sum. Instead, the weight of each element can be relative to the others.

For instance, if we have a list of fruits and we want to give twice as much weight to apples than we do to bananas, we can assign a the following weights:

```
import random
list = ['apple', 'banana', 'cherry', 'durian']
weights = [2, 1, 1, 5/2]
selection = random.choices(list, weights)
print(selection)
```

The `apple`

in this case is twice as likely to be choose than `banana`

. Note that the weights do not have be in integers.

We can also represent the weights in fractions and decimal points.

### Cumulative Weights to Choose Elements with Different Probability

Alternatively, one can also use cumulative weights to decide the probability of selecting an element. Cumulative weight is the sum of all the weights up to that element.

One can generate the cumulative weight of the given elements using numpy’s `cumsum()`

function.

### Probability of Getting 6 or More Heads from 10 Spins

Suppose you have a coin that is biased, and when tossed, it lands on heads 70% of the time and tails 30% of the time. What is the probability of getting 6 or more heads in 10 spins?

You can simulate this scenario using `numpy.random.choice()`

.

```
import numpy as np
outcomes = ['H', 'T']
weights = [0.7, 0.3]
sum(np.random.choice(outcomes, size=10, p=weights) == 'H') >= 6
```

This code will simulate 10 coin tosses with the given weight of 0.7 for heads and 0.3 weight for tails. The last line will return `True`

if the outcome has 6 or more heads.

### Generate Weighted Random Numbers

We can use `numpy.random.choice()`

to generate a list of random numbers with a given weightage. Consider the following example:

```
import numpy as np
weightage = [1, 2, 3, 4]
np.random.choice(4, 5, replace=True, p = weightage/np.sum(weightage))
```

In this code, we have assigned weightage to each of the four elements. We now use `np.random.choice()`

to generate 5 random numbers assigned to these element.

Note that we have used `replace=True`

, which allows sampling with replacement.

### Weighted Random Sampling with `numpy.random.choice()`

A similar function that is widely used is `numpy.random.choice()`

.

It accepts a sequence and a weightage list, similar to `random.choices()`

. The difference lies in how the weights are treated.

`numpy.random.choice()`

requires the weights to be normalized i.e., sum of the weights must be equal to 1.

### Choosing Elements with Different Probabilities

Using `numpy.random.choice()`

with normalized weightage is simple as shown in the example below:

```
import numpy as np
list = ['apple', 'banana', 'cherry', 'durian']
weightage = [0.3, 0.2, 0.1, 0.4]
selection = np.random.choice(list, size=1, p=weightage)
print(selection)
```

## Conclusion

In this article, we discussed weighted random sampling and two popular methods for performing such operations. `Random.choices()`

function from Python’s `random`

module allows the user to specify a weight for each element.

`Numpy.random.choice()`

function accepts a sequence and a weightage list, which must be normalized as summed up to 1. Regardless of the method chosen, weighted random sampling enables the user to consider the probability distribution when selecting data from a population.

In the world of data analysis and research, it is often necessary to generate random data for various tasks. Sometimes, however, not all elements of the population are equally likely to be selected.

In such cases, Weighted Random Sampling is used to consider the probability distribution when selecting data from a population. In this article, we have provided an overview of two popular methods for weighted random sampling using the Python programming language – `random.choices()`

and `numpy.random.choice()`

.

### Weighted Random Sampling with `random.choices()`

The `random.choices()`

function in Python is used to select a random element from a given sequence. It also allows the user to specify a weight for each element, indicating the likelihood of that element being selected.

Using the relative weights or cumulative weights one can also select elements with different probabilities. Weighted Random Sampling with `numpy.random.choice()`

`numpy.random.choice()`

is a similar function where the user can assign weights to elements.

However, the weights must be normalized, i.e., sum up to 1. In this function, the probability distribution for each element is determined by the weight of that element.

In the examples provided, we showed how to use these functions to generate weighted random samples. In the code snippets, we used different lists and sequences and assigned weights to elements present in them.

We learned how to set the weight of each element relative to others, using fractional weights, and how to normalize weights.

## Summary

Weighted random sampling is a technique that accounts for the probability distribution of a population. It is beneficial in scenarios when selecting data from a population where each element’s likelihood of selection differs.

Python offers two popular methods, namely `random.choices()`

and `numpy.random.choice()`

, to perform weighted random sampling. The former allows the user to specify the relative or cumulative weight of each element present in the population, whereas the latter demands normalized weights.

## Next Steps

Weighted random sampling can be a critical data analysis tool, especially in areas where elements of the population are unevenly distributed. Learn more about the different ways of assigning weights to elements and how to use them for various applications.

The concepts and examples discussed in this article can be used in various fields such as finance, medicine, social sciences, and AI. Moreover, once comfortable with weighted random sampling, one can dive deeper into other related topics like probability theory, Monte Carlo simulations, and statistical inference.

In conclusion, the ability to generate weighted random samples is a fundamental tool in the field of data analysis and research. Both the `random.choices()`

and `numpy.random.choice()`

methods, as detailed in this article, can provide insights into different scenarios, ranging from simulating coin tosses to selecting data for large-scale research projects.

Understanding how weighted random sampling works will prove useful for many applications, and we encourage readers to explore these concepts in more depth and use them in their projects. Weighted random sampling is a crucial tool for data analysis to produce random data for a population where the probability distribution for each element’s selection varies.

Python programming language offers two popular methods to perform this technique, `random.choices()`

, and `numpy.random.choice()`

. The former allows the user to specify the weight of each element.

In contrast, the latter requires normalized weight. We have demonstrated the use of both functions using different examples, including relative weights, cumulative weights, probability, and weighted random numbers.

It’s important to understand how weighted random sampling works to generate useful insights for various scenarios, such as AI, social sciences, finance and medical research. Further exploration of probability theory, Monte Carlo simulations and statistical inference can help gain a better understanding of the topic.