12.3: Broadcasting

In NumPy, broadcasting refers to the practice of performing operations on arrays of different shapes and sizes in a manner that "broadcasts" the smaller array across the larger one. This concept is particularly useful for efficient memory utilization and computational speed, as it eliminates the need to explicitly replicate the smaller array multiple times to match the shape of the larger array. Imagine you have a 2D array (often called a matrix) and you want to add a 1D array (a vector) to each row of that matrix. You could use a loop to manually add the vector to each row, but that wouldn't be computationally efficient. Broadcasting automates this process. When you add the matrix and the vector together, NumPy automatically understands that you intend to add the vector to each row of the matrix. The dimensions are implicitly expanded to align the shapes of the arrays being operated upon. This intrinsic feature of NumPy enables cleaner code, faster execution, and overall, a more elegant handling of mathematical operations between arrays.

For example, let's say you have a NumPy array representing grades for a class. In this array, each row corresponds to a student and each of the three columns corresponds to an exam. You've decided to add curve points to the exams: 3 points for the first exam, 5 points for the second, and 10 points for the third. You could accomplish this task using a for loop to iterate over each column and add the corresponding curve points to all the rows in that column. While this may not be the most efficient method, it serves as an instructive example for understanding basic array manipulations.

Here's how you could code this using a for loop:

import numpy as np

# Grades for 6 students over 3 exams
grades = np.array([[80, 85, 88],
                   [76, 80, 82],
                   [92, 94, 96],
                   [65, 70, 75],
                   [90, 85, 88],
                   [70, 75, 80]])

# Curve points for each exam
curve_points = np.array([3, 5, 10])

# Loop through each column (exam) and add curve points
for i in range(len(curve_points)):
    grades[:, i] = grades[:, i] + curve_points[i]

print("Curved grades:")
print(grades)

output:

[[ 83  90  98]
 [ 79  85  92]
 [ 95  99 106]
 [ 68  75  85]
 [ 93  90  98]
 [ 73  80  90]]

In this example, the `for` loop iterates through each of the three columns of the `grades` array and adds the curve points to all the rows in that column.

In NumPy, the concept of broadcasting allows you to elegantly and efficiently apply operations across arrays of different shapes. When adding curve points to each exam in our example, you can take advantage of broadcasting to sidestep explicit looping, thereby enhancing computational efficiency. You have a 2D array of grades with 6 rows (students) and 3 columns (exams), and you want to add an array of curve points with shape `(3,)` to each row.

Here's how you could do this using broadcasting:

import numpy as np

# Grades for 6 students over 3 exams
grades = np.array([[80, 85, 88],
                   [76, 80, 82],
                   [92, 94, 96],
                   [65, 70, 75],
                   [90, 85, 88],
                   [70, 75, 80]])

# Curve points for each exam
curve_points = np.array([3, 5, 10])

# Add curve points to grades using broadcasting
grades = grades + curve_points

print("Curved grades:")
print(grades)

This generates the same output!

In this example, the `curve_points` array has shape `(3,)`, and the `grades` array has shape `(6, 3)`. When you perform the operation `grades = grades + curve_points`, NumPy takes the 3-element array and reshapes it to a 1 by 3 array.  Then, it can copy the rows until it's a 6 by 3 array and can directly add the two arrays.

In other words, the dimensions of the 3-element array are automatically reconciled so that the `curve_points` array is virtually stretched, or "broadcast," over the shape of the `grades` array, allowing the addition to occur element-wise across all rows for each column.

Thus, broadcasting provides a more efficient, less verbose, and arguably more readable way to perform operations like this compared to traditional for-loop constructs.FM

Broadcasting is one of the hardest concepts in NumPy, so if you feel a bit unsure, don't worry about it.  Here's a video you can watch that will help you understand this.  And here's another one.