This tutorial is from open-source community. Access the source code
Broadcasting is a powerful feature in NumPy that allows arrays with different shapes to be used in arithmetic operations. It provides a way to vectorize array operations and improve computational efficiency. This lab will guide you through the basics of broadcasting in NumPy.
Note: You can write code in
05-broadcasting.ipynb. Some printing operations are omitted in the steps, and you can print output as needed.
Broadcasting allows NumPy to perform element-wise operations on arrays with different shapes. The smaller array is automatically "broadcast" to match the shape of the larger array. This is done under certain constraints, which we will explore in the following steps.
In the simplest case, two arrays must have exactly the same shape for element-wise operations. For example:
import numpy as np
a = np.array([1.0, 2.0, 3.0])
b = np.array([2.0, 2.0, 2.0])
result = a * bIn this case, a and b have the same shape, so the multiplication is done element-wise and the result is [2.0, 4.0, 6.0].
Broadcasting also allows for element-wise operations between an array and a scalar value. The scalar value is automatically "stretched" to match the shape of the array. For example:
import numpy as np
a = np.array([1.0, 2.0, 3.0])
b = 2.0
result = a * bIn this case, b is a scalar value, but it is stretched to become an array with the same shape as a. The multiplication is then done element-wise, resulting in [2.0, 4.0, 6.0].
NumPy compares the shapes of two arrays element-wise to determine if they are compatible for broadcasting. The following rules apply:
If these conditions are not met, a ValueError is raised, indicating that the arrays have incompatible shapes.
Let's look at some examples to understand how broadcasting works in different scenarios.
import numpy as np
a = np.array([[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0]])
b = np.array([1.0, 2.0, 3.0])
result = a + bIn this case, b is added to each row of a. The result is a 2D array with the same shape as a, where each element is the sum of the corresponding elements in a and b.
import numpy as np
a = np.array([[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0]])
b = np.array([1.0, 2.0])
result = a + bIn this case, broadcasting fails because the trailing dimensions of a and b are not equal. It is impossible to align the values in the rows of a with the elements of b for element-wise addition.
Let's explore a practical example where broadcasting is useful. Consider the vector quantization (VQ) algorithm used in information theory and classification. The basic operation in VQ is to find the closest point in a set of points to a given point. This can be done using broadcasting. Here's an example:
import numpy as np
observation = np.array([111.0, 188.0])
codes = np.array([[102.0, 203.0],
[132.0, 193.0],
[45.0, 155.0],
[57.0, 173.0]])
diff = codes - observation
dist = np.sqrt(np.sum(diff**2, axis=-1))
closest_index = np.argmin(dist)
closest_code = codes[closest_index]In this example, observation represents the weight and height of an athlete to be classified, and codes represents different classes of athletes. By subtracting observation from codes, broadcasting is used to calculate the distance between observation and each of the codes. The argmin function is then used to find the index of the closest code.
In this lab, we learned about broadcasting in NumPy. Broadcasting allows for element-wise operations on arrays with different shapes, making it a powerful tool for vectorizing array operations and improving computational efficiency. By understanding the broadcasting rules and using it appropriately, you can simplify and optimize your code.
