Broadcasting¶
Broadcasting is a powerful mechanism that allows numpy to work with arrays of different shapes when performing arithmetic operations.
Broadcasting solves the problem of arithmetic between arrays of differing shapes by in effect replicating the smaller array along the last mismatched dimension.
import numpy as np
NumPy operations are usually done on pairs of arrays on an element-by-element basis. In the simplest case, the two arrays must have exactly the same shape, as in the following example:
a = np.array([1,2,3,4,5])
b = np.array([10,10,10,10,10])
a * b
array([10, 20, 30, 40, 50])
If the dimensions of two arrays are dissimilar, element-to-element operations are not possible. However, operations on arrays of non-similar shapes is still possible in NumPy, because of the broadcasting capability. The smaller array is broadcast to the size of the larger array so that they have compatible shapes.
Scalar and One-Dimensional Array¶
A single value or scalar can be used in arithmetic with a one-dimensional array.
c = 10
a * c
array([10, 20, 30, 40, 50])
The result is equivalent to the previous example where b was an array. We can think of the scalar c being stretched during the arithmetic operation into an array with the same shape as a. The new elements in c are simply copies of the original scalar.
Scalar and n-Dimensional Array¶
A scalar value can be used in arithmetic with a n-dimensional array.
one = np.ones((4,3))
one * c
array([[10., 10., 10.],
[10., 10., 10.],
[10., 10., 10.],
[10., 10., 10.]])
One-Dimensional and n-Dimensional Arrays¶
A one-dimensional array can be used in arithmetic with a n-dimensional array.
Consider the following example: We have the heights (in cm) and weights ( in pounds) of a group of students. We store this information in an array called student_bio.
Heights are in cm
Weights are in kgs
heights = [165,170,168,183,172,169]
weights = [61,76,56,81,62,60]
student_bio = np.array([heights,weights])
student_bio
array([[165, 170, 168, 183, 172, 169],
[ 61, 71, 56, 79, 62, 60]])
Now, we would like to convert heights into feet and weights into kilograms, for that the conversion factors are 0.0328084 and 2.20462 respectively
factor_1 = np.array([0.0328084,2.20462 ])
factor_1
array([0.0328084, 2.20462 ])
factor_1.shape
(2,)
student_bio.shape
(2, 6)
General Broadcasting Rules¶
When operating on two arrays, NumPy compares their shapes element-wise. The dimensions are considered in reverse order, starting with the trailing dimensions, and working its way forward. Two dimensions are compatible when
they are equal,
one of them is of size 1
Shape mismatch¶
This fails because there is a mismatch in the trailing dimensions
student bio: 2 x 6
factor_1: 2
The trailing dimensions here are 6 and 2, so there is a mismatch
student_bio * factor_1
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-15-55988f53db6d> in <module>()
----> 1 student_bio * factor_1
ValueError: operands could not be broadcast together with shapes (2,6) (2,)
factor_2 = np.array([[0.0328084],[2.20462 ]])
factor_2
array([[0.0328084],
[2.20462 ]])
factor_2.shape
(2, 1)
Dimensions match¶
The dimensions are:
2 x 6
2 x 1
Here, the last dimensions are 6,1 so they match on account of one of them being 1
The next dimensions are 2,2 so there is a match
student_bio * factor_2
array([[ 5.413386 , 5.577428 , 5.5118112, 6.0039372, 5.6430448,
5.5446196],
[134.48182 , 156.52802 , 123.45872 , 174.16498 , 136.68644 ,
132.2772 ]])
Why did we encounter an error for the first try?
Broadcasting is possible only when certain rules are satisfied, it does not work for all cases, and imposes a strict rule that must be satisfied for broadcasting to be performed.
The dimensions with size 1 are stretched or “copied” to match the other.
After application of the broadcasting rules, the sizes of all arrays must match.
In the above example, factor is stretched to match with the dimensions of students_bio in order to carry out operations.