Matrix Multiplication in NumPy

Element-wise Multiplication

In NumPy, element-wise multiplication multiplies corresponding elements from two arrays of the same shape. This is not matrix multiplication — it’s more like multiplying values cell by cell.

You can perform element-wise multiplication using the * operator:

import numpy as np

# Define two arrays
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Element-wise multiplication
result = a * b

print(result)

import numpy as np

# Define two arrays
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Element-wise multiplication
result = a * b

print(result)

How It Works:

• a and b must have the same shape (or be broadcastable).
• a * b multiplies each element of a with the corresponding element of b.
• The result is a new array of the same shape.
• Example calculation:
• result = [1*4 2*5 3*6] = [4 10 18]

Output

[ 4 10 18 ]

[ 4 10 18 ]

You can also perform element-wise multiplication on 2D arrays:

a = np.array([[1, 2],
                  [3, 4]])

b = np.array([[5, 6],
              [7, 8]])

result = a * b

print(result)

a = np.array([[1, 2],
                  [3, 4]])

b = np.array([[5, 6],
              [7, 8]])

result = a * b

print(result)

How It Works (2D):

• Each element in the same position in both arrays is multiplied together.
• Example calculation:
• result = [[1*5, 2*6], [3*7, 4*8]] = [[5, 12], [21, 32]]
• The output retains the same shape: (2, 2).

Output

[[ 5 12]
 [21 32]]

[[ 5 12]
 [21 32]]

This is especially useful for operations like scaling, applying masks, or combining data in a pointwise fashion.

💡 Tip: For actual matrix multiplication, use np.dot(), np.matmul(), or the @ operator — we'll explore those next.

Matrix Multiplication

Unlike element-wise multiplication, matrix multiplication follows the rules of linear algebra. NumPy provides multiple ways to perform matrix multiplication, including np.dot(), np.matmul(), and the @ operator (Python 3.5+).

The number of columns in the first matrix must match the number of rows in the second matrix. The resulting matrix has the shape: (rows of A, columns of B).

import numpy as np

# Define two matrices
A = np.array([[1, 2],
              [3, 4]])

B = np.array([[5, 6],
              [7, 8]])

# Matrix multiplication using np.dot()
result_dot = np.dot(A, B)

# Using np.matmul()
result_matmul = np.matmul(A, B)

# Using @ operator
result_operator = A @ B

print(result_dot)
print(result_matmul)
print(result_operator)

import numpy as np

# Define two matrices
A = np.array([[1, 2],
              [3, 4]])

B = np.array([[5, 6],
              [7, 8]])

# Matrix multiplication using np.dot()
result_dot = np.dot(A, B)

# Using np.matmul()
result_matmul = np.matmul(A, B)

# Using @ operator
result_operator = A @ B

print(result_dot)
print(result_matmul)
print(result_operator)

Output

[[19 22]
 [43 50]]

[[19 22]
 [43 50]]

How It Works:

• Each element is computed by taking the dot product of a row from A and a column from B.
• result[0][0] = 1×5 + 2×7 = 19
• result[0][1] = 1×6 + 2×8 = 22
• result[1][0] = 3×5 + 4×7 = 43
• result[1][1] = 3×6 + 4×8 = 50

Which One Should You Use?

• np.dot(): Works only for 1D and 2D arrays. It performs dot product for 1D and matrix multiplication for 2D, but does not support higher-dimensional arrays. Can be ambiguous.
• np.matmul(): Explicit matrix multiplication. Supports 2D and higher-dimensional (e.g., 3D batch) arrays. Recommended for most use cases.
• @: Clean and modern syntax for matrix multiplication (equivalent to np.matmul()). Requires Python 3.5+.

💡 Tip: Use @ or np.matmul() when you want clear matrix multiplication — especially in deep learning and numerical simulations.

Example 1: Multiplying 3×3 Matrices

In NumPy, you can multiply two 3×3 matrices using np.matmul() or the @ operator. This is a common operation in linear algebra, graphics, and scientific computing.

import numpy as np

# Define matrix A (3x3)
A = np.array([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
])

# Define matrix B (3x3)
B = np.array([
  [9, 8, 7],
  [6, 5, 4],
  [3, 2, 1]
])

# Perform matrix multiplication
result = A @ B

print(result)

import numpy as np

# Define matrix A (3x3)
A = np.array([
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
])

# Define matrix B (3x3)
B = np.array([
  [9, 8, 7],
  [6, 5, 4],
  [3, 2, 1]
])

# Perform matrix multiplication
result = A @ B

print(result)

How It Works:

• A has shape (3, 3): a 3×3 matrix.
• B has shape (3, 3): another 3×3 matrix.
• A @ B computes the matrix product, resulting in another 3×3 matrix.

Output

[[ 30  24  18]
 [ 84  69  54]
 [138 114  90]]

[[ 30  24  18]
 [ 84  69  54]
 [138 114  90]]

The resulting matrix contains the products of rows of A with columns of B, as per matrix multiplication rules.

What's Next?

Coming up next, we’ll explore the concept of the Inverse of a Matrix in NumPy — a key operation in linear algebra that's essential for solving systems of equations, performing transformations, and many applications in machine learning and scientific computing.