Matrix Multiplication with np.matmul and @

Matrix multiplication is at the heart of data science and machine learning. It underpins neural networks, dimensionality reduction, and linear transformations. In Python, NumPy gives you two clean ways to multiply matrices: the np.matmul() function and the @ operator introduced in Python 3.5. Both are fast, vectorized, and far more efficient than nested Python loops.

For two matrices A and B, the product A @ B is valid only when the number of columns in A equals the number of rows in B. If A is shape (m, n) and B is shape (n, k), the result is shape (m, k). This rule is called the inner-dimension constraint and applies regardless of which NumPy function you use.

np.matmul(A, B) and A @ B produce identical results for 2-D arrays. The @ operator is simply syntactic sugar — it calls __matmul__ under the hood, which NumPy implements with the same C-level BLAS routine. Use @ in everyday code for readability; use np.matmul when you want to pass the function as a callable or handle edge cases explicitly.

NumPy has three multiplication functions that are easy to confuse. A * B is element-wise multiplication (Hadamard product). np.dot(A, B) behaves like np.matmul for 2-D arrays but has different semantics for higher dimensions. A @ B is strictly matrix multiplication and follows the mathematical definition precisely — prefer it over np.dot for matrix work.

Unlike scalar multiplication, matrix multiplication is not commutative: A @ B generally differs from B @ A. The shapes may not even be compatible in both directions. This matters when writing transformations — the order of operations changes the result. Always keep track of which matrix is on the left versus the right.

When your arrays have more than two dimensions, np.matmul and @ treat the extra leading dimensions as batch dimensions and multiply matrices in parallel. For example, an array of shape (32, 3, 4) multiplied by one of shape (32, 4, 5) produces a result of shape (32, 3, 5) — 32 independent 3×4 @ 4×5 multiplications at once. This is how deep learning frameworks process mini-batches efficiently.

A common special case is multiplying a matrix by a vector. If A is shape (m, n) and v is a 1-D array of length n, then A @ v produces a 1-D array of length m. NumPy handles the shape alignment automatically — you do not need to reshape v into a column vector. This pattern appears everywhere: applying weights in linear regression, projecting features, and computing dot products for each row simultaneously.

NumPy matrix multiplication calls optimized BLAS/LAPACK routines and runs in compiled C code. A pure Python nested loop implementing the same operation is typically 100–1000× slower for large matrices. When you need repeated matrix products in a data pipeline — feature transformations, PCA projections, weight updates — always use @ or np.matmul and never implement the inner loop yourself.

You can chain multiple @ operations in one expression: A @ B @ C evaluates left to right. NumPy does not optimize the multiplication order automatically (unlike MATLAB's mtimes), so if the matrices have very different sizes, the order can matter for speed. For three or more matrices consider using np.linalg.multi_dot([A, B, C]), which automatically selects the most efficient pairing.

The most common error with matrix multiplication is a shape mismatch: ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0. The fix is to check shapes with A.shape and ensure the inner dimensions agree. If you have a row vector of shape (n,) that needs to be treated as a column vector (n, 1), use v.reshape(-1, 1). If you need the transpose, use A.T.

A typical data science use case: you have a dataset X of shape (n_samples, n_features) and a weight matrix W of shape (n_features, n_outputs). The matrix product X @ W applies a linear transformation to every sample simultaneously, producing shape (n_samples, n_outputs). This is the core computation of a linear layer in a neural network and of linear regression prediction.

Test your understanding of NumPy matrix multiplication.

In this lesson you learned: np.matmul and @ implement true matrix multiplication (not element-wise), the inner dimensions of the two matrices must match, and @ supports batched multiplication over leading dimensions. Next up we explore determinants, inverses, and transposes — the operations that tell you whether a matrix can be 'undone'.