Data Tables & Transformations (Matrices)

You already know vectors — ordered lists of numbers that represent data points. But what happens when you stack many vectors together? You get a matrix — a rectangular grid of numbers. Every spreadsheet, every dataset, every neural network layer is built on matrices.

In this article, you will learn what matrices are, how to multiply them (and why the definition is not arbitrary), and why this single operation is the computational heart of modern AI.

What Is a Matrix?

Three houses with the features area, rooms, and year built form a 3×3 matrix. Each row is a house, each column is a feature.

import numpy as np

# Three houses as a 3x3 matrix
houses = np.array([
    [120, 4, 1990],
    [85,  3, 2005],
    [200, 6, 1975]
])
print(houses.shape)     # (3, 3)
print(houses[1, 2])     # 2005 — year built of house 2

Every dataset in machine learning is a matrix: rows are examples, columns are features. And every network layer is a matrix transformation.

Matrix Multiplication — Why This Definition?

Matrix multiplication looks complicated at first — but it has a deep reason: It exactly describes the composition of two transformations. Apply matrix B first, then matrix A, and the result is the matrix AB.

Each element c_ij of the result is the dot product of row i of A with column j of B. The connection to the vectors article: matrix multiplication consists of many dot products.

The inner dimensions must match. An (m×n) matrix times an (n×p) matrix produces an (m×p) matrix. If the inner dimensions do not match, multiplication is undefined.

import numpy as np

# Weight matrix W (2x3) times input vector x (3x1)
W = np.array([[0.5, -0.3, 0.8],
              [0.1,  0.7, -0.2]])
x = np.array([1, 2, 3])

print(W @ x)          # [2.3, 0.9]
print(W.shape, '@', x.shape, '→', (W @ x).shape)
# (2, 3) @ (3,) → (2,)

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

print(A * B)   # [[ 5, 12], [21, 32]] — elementwise
print(A @ B)   # [[19, 22], [43, 50]] — matrix multiplication

Matrices in Neural Networks — Why GPUs Calculate

Every fully connected layer of a neural network computes exactly one matrix multiplication: weight matrix times input plus bias. Training means adjusting the entries of the weight matrix to reduce the error.

Instead of processing one vector at a time, many inputs are stacked into a matrix. This way, an entire batch (e.g., 32 images) is processed in ONE matrix multiplication. This is dramatically faster.

Why are GPUs so fast at this? Because each dot product in a matrix multiplication can be computed completely independently of the others. A CPU has a few very fast cores (e.g., 16). A GPU has thousands of slower cores (e.g., 10,000). For matrices — where thousands of simple calculations happen simultaneously — the GPU is dramatically superior.

import numpy as np

# Mini-network: 5 data points, 3 features
X = np.random.randn(5, 3)       # Input: (5, 3)
W1 = np.random.randn(3, 4)      # Layer 1: (3, 4)
W2 = np.random.randn(4, 2)      # Layer 2: (4, 2)

hidden = X @ W1                  # (5, 3) @ (3, 4) = (5, 4)
output = hidden @ W2             # (5, 4) @ (4, 2) = (5, 2)
print(f'Input: {X.shape} → Hidden: {hidden.shape} → Output: {output.shape}')

# Shape chain visualized:
# (batch × features_in) @ (features_in × features_out) = (batch × features_out)
#   5 × 3               @          3 × 4              =       5 × 4
#   5 × 4               @          4 × 2              =       5 × 2
# The inner dimension must always match!

Interactive: The Most Famous 2×2 Matrix in ML

A neural network classifies inputs into categories — but how well? Quality is measured with a confusion matrix: a 2×2 matrix of True Positives, False Negatives, False Positives, and True Negatives. Adjust the parameters and observe how the four cells of the matrix shift — especially with rare events (low prevalence), the results are surprisingly counterintuitive.