NumPy array multiplication refers to the process of multiplying two arrays element-wise. In this context, element-wise multiplication means that each element in one array is multiplied by the corresponding element in the other array.
The result is a new array where each element represents the product of the corresponding elements from the input arrays.
Element-wise multiplication, also known as Hadamard product, is an operation in NumPy where two arrays of the same shape are multiplied together, and the operation is applied to each corresponding pair of elements.
For element-wise multiplication to be performed, the two arrays must have the same shape. If the arrays are of different shapes, broadcasting rules are applied to make them compatible.
In the following example, we are multiplying each element of array a by the corresponding element of array b −
# Open Compiler import numpy as np # Creating two arrays a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) # Performing element-wise multiplication result = a * b print(result)
Output:
Following is the output obtained −
[ 4 10 18]
Scalar multiplication refers to multiplying every element of an array by a single scalar value. Each element in the array is multiplied by the scalar value, resulting in a new array where all elements are scaled accordingly.
The shape of the resulting array is the same as the original array, but each element is scaled by the scalar.
In this example, we are multiplying the scalar “3” with each element of the array “a” −
# Open Compiler import numpy as np # Creating an array a = np.array([1, 2, 3]) # Multiplying by a scalar result = a * 3 print(result)
Output:
This will produce the following result −
[3 6 9]
When multiplying arrays of different shapes, NumPy uses broadcasting to make the shapes compatible for element-wise operations. Broadcasting aligns dimensions from the rightmost side, adjusts shapes according to specific rules, and performs the operation smoothly.
In the example below, array “b” is broadcasted to match the shape of array “a”, and then element-wise multiplication is performed −
# Open Compiler import numpy as np # Creating arrays with different shapes a = np.array([[1, 2, 3], [4, 5, 6]]) b = np.array([10, 20, 30]) # Multiplying arrays with broadcasting result = a * b print(result)
Output:
Following is the output of the above code −
[[10 40 90]
[40 100 180]]
Matrix multiplication is an operation in linear algebra where two matrices are multiplied according to specific rules. In NumPy, this operation is performed using the np.dot() function, the @ operator, or the np.matmul() function.
For matrix multiplication to be valid, the number of columns in the first matrix must be equal to the number of rows in the second matrix. If matrix A has shape (m, n) and matrix B has shape (n, p), the resulting matrix will have shape (m, p).
The np.dot() function in NumPy is used for calculating dot products of two arrays. It handles both matrix multiplication for 2D arrays and dot products for 1D arrays −
# Open Compiler
import numpy as np
# Define two matrices
matrix1 = np.array([[1, 2],
[3, 4]])
matrix2 = np.array([[5, 6],
[7, 8]])
# Perform matrix multiplication using np.dot
result = np.dot(matrix1, matrix2)
print(result)
Output:
The output obtained is as shown below −
[[19 22]
[43 50]]
The @ operator in NumPy provides a shorthand for the np.dot() function. It performs matrix multiplication for 2D arrays and is used to calculate the dot product for 1D arrays −
# Open Compiler
import numpy as np
# Define the same matrices
matrix1 = np.array([[1, 2],
[3, 4]])
matrix2 = np.array([[5, 6],
[7, 8]])
# Perform matrix multiplication using the @ operator
result = matrix1 @ matrix2
print(result)
Output:
After executing the above code, we get the following output −
[[19 22]
[43 50]]
The np.matmul() function can handle arrays with more than two dimensions by performing matrix multiplication on the last two dimensions of the input arrays, with any preceding dimensions being broadcasted as needed −
# Open Compiler
import numpy as np
# Define a 3D array and a 2D array
array_3d = np.array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
array_2d = np.array([[1, 0],
[0, 1]])
# Perform matrix multiplication using np.matmul
result = np.matmul(array_3d, array_2d)
print(result)
Output:
The result produced is as follows −
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
It is important to differentiate between element-wise multiplication (using *) and matrix multiplication (using @ or np.dot()) −
In this example, we are highlighting the difference between element-wise multiplication and matrix multiplication −
# Open Compiler
import numpy as np
# Creating two 2D arrays
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
# Element-wise multiplication
element_wise_result = a * b
print("Element-wise multiplication:\n", element_wise_result)
# Matrix multiplication
matrix_result = np.dot(a, b)
print("Matrix multiplication:\n", matrix_result)
Output:
We get the output as shown below −
Element-wise multiplication:
[[ 5 12]
[21 32]]
Matrix multiplication:
[[19 22]
[43 50]]
When multiplying arrays with different data types in NumPy, type coercion rules are applied to ensure that the operation can be performed. This process involves converting the arrays to a common data type before performing the multiplication.
NumPy uses a set of promotion rules to determine the data type of the result. The general rule is to convert the operands to the type that can hold the result without losing precision. Following is the promotion order −
For example, integer and floating-point numbers are promoted to floating-point types to accommodate decimal values.
In this case, NumPy promotes the integer array b to a float type to match the data type of array a −
# Open Compiler import numpy as np # Creating arrays with different data types a = np.array([1.5, 2.5, 3.5]) b = np.array([2, 3, 4], dtype=np.int32) # Performing multiplication result = a * b print(result)
Output:
Following is the output obtained −
[3. 7.5 14.]
When performing multiplication operations between arrays in NumPy, dimension mismatch can occur if the arrays do not share compatible shapes. NumPy addresses this issue through broadcasting and raises a ValueError in such cases.
In the following example, the shapes of “a” and “b” are not compatible for broadcasting, leading to an error −
# Open Compiler import numpy as np # Creating arrays with incompatible shapes a = np.array([1, 2, 3]) b = np.array([[1, 2], [3, 4]]) # Attempting to multiply incompatible arrays result = a * b print(result)
Output:
The result produced is as follows −Traceback (most recent call last):
File "/home/cg/root/66a1de2fae52f/main.py", line 8, in
result = a * b
ValueError: operands could not be broadcast together with shapes (3,) (2,2)
Key Takeaway: Master NumPy array multiplication and matrix operations at Vista Academy!