Vectors and matrices: the language of data

import pandas as pd
import numpy as np

df = pd.read_csv(DATA / "uy_ijara.csv")
num = ["xonalar", "maydon_m2", "metro_km", "mebel"]

one = df.loc[0, num]
print("One flat (one row):")
print(one.to_string())
print()
x = one.to_numpy(dtype=float)
print("numpy vector:", x)
print("shape:", x.shape, " -> 4 numbers")

X = df[num].to_numpy(dtype=float)
print("The whole table:")
print(f"  shape: {X.shape}  ->  {X.shape[0]} rows (samples), {X.shape[1]} columns (features)")
print()
print("First 3 rows:")
print(X[:3])
print()
print("Taking elements from the matrix:")
print(f"  X[0, 1] = {X[0, 1]}      -> row 1, column 2 (the first flat's area)")
print(f"  X[0]    = {X[0]}  -> the whole of row 1 (one flat)")
print(f"  X[:, 1][:5] = {X[:, 1][:5]}  -> the first 5 values of column 2 (areas)")

# weights: how much each feature affects the price
w = np.array([55.0, 7.5, -28.0, 90.0])
b = 180.0            # bias (the starting value)

print("The weights and what they mean:")
for name, weight in zip(num, w):
    print(f"  {name:12s} {weight:>7.1f}")
print(f"  {'bias':12s} {b:>7.1f}")
print()
print("A prediction for one flat, BY HAND:")
steps = [f"{x[i]:.2f} x {w[i]:.1f}" for i in range(len(w))]
print("  " + " + ".join(steps) + f" + {b:.0f}")
pred_by_hand = sum(x[i] * w[i] for i in range(len(w))) + b
print(f"  = {pred_by_hand:.2f}")

pred_dot = x @ w + b              # @ is the dot-product operator
print(f"x @ w + b = {pred_dot:.2f}")
print(f"By hand   : {pred_by_hand:.2f}")
print(f"The same  : {np.isclose(pred_dot, pred_by_hand)}")

import time

# Way 1: with a loop
t0 = time.perf_counter()
preds_loop = []
for i in range(len(X)):
    s = 0.0
    for j in range(X.shape[1]):
        s += X[i, j] * w[j]
    preds_loop.append(s + b)
loop_time = time.perf_counter() - t0
preds_loop = np.array(preds_loop)

# Way 2: matrix multiplication
t0 = time.perf_counter()
preds_vec = X @ w + b
vec_time = time.perf_counter() - t0

print(f"With a loop : {loop_time*1000:.2f} ms")
print(f"With X @ w  : {vec_time*1000:.4f} ms")
print(f"Same results: {np.allclose(preds_loop, preds_vec)}")
print(f"Speed-up    : {loop_time/max(vec_time, 1e-9):.0f}x")

print(f"X shape     : {X.shape}")
print(f"w shape     : {w.shape}")
print(f"X @ w shape : {(X @ w).shape}   -> one number per row")
print()
print("First 5 predictions:", (X @ w + b)[:5].round(1))
print("Actual prices      :", df.narx_usd.head(5).to_numpy())

A = np.array([[1., 2., 3.], [4., 5., 6.]])        # 2x3
B = np.array([[1., 0.], [0., 1.], [1., 1.]])      # 3x2
print(f"A shape: {A.shape}")
print(f"B shape: {B.shape}")
print(f"A @ B  : {(A @ B).shape}   <- the 3 and the 3 MATCHED, the result is 2x2")
print(A @ B)
print()
try:
    B @ A @ B @ A
except ValueError as e:
    pass
try:
    _ = A @ A
except ValueError as e:
    print("A @ A raises an error:", str(e)[:62])
print()
print("RULE: (n x m) @ (m x k) = (n x k).  The two middle numbers MUST match.")

print(f"X shape   : {X.shape}")
print(f"X.T shape : {X.T.shape}   <- rows and columns swapped")
print()
print("Why you need it: to compute how columns relate to each other")
Xm = X - X.mean(axis=0)                      # centring
cov = (Xm.T @ Xm) / (len(X) - 1)             # covariance matrix
print(f"Xm.T @ Xm shape: {cov.shape}   <- 4x4, one number per pair of columns")
print()
print("Correlation (normalised from the covariance):")
std = np.sqrt(np.diag(cov))
corr = cov / np.outer(std, std)
print(pd.DataFrame(corr.round(3), index=num, columns=num).to_string())

print("Subtracting each column's mean from it, NO LOOP NEEDED:")
print(f"  X shape           : {X.shape}")
print(f"  X.mean(axis=0)    : {X.mean(axis=0).shape}  -> 4 numbers")
centred = X - X.mean(axis=0)
print(f"  X - mean result   : {centred.shape}  <- numpy SPREAD the 4 numbers over 1200 rows")
print()
print(f"  Check: the new means: {centred.mean(axis=0).round(10)}")
print()
print("This is broadcasting. It is exactly what happens inside StandardScaler:")
scaled = (X - X.mean(axis=0)) / X.std(axis=0)
print(f"  mean: {scaled.mean(axis=0).round(6)}")
print(f"  std : {scaled.std(axis=0).round(6)}")

a = np.array([1, 2, 3])
bb = np.array([[1], [2], [3]])
print(f"a shape     : {a.shape}")
print(f"b shape     : {bb.shape}")
print(f"a + b shape : {(a + bb).shape}   <- you expected 3 numbers, you got 9")
print(a + bb)

v = np.array([3.0, 4.0])
print(f"v = {v}")
print()
print(f"L2 norm (Euclidean) : {np.linalg.norm(v, 2):.4f}   = sqrt(3^2 + 4^2)")
print(f"L1 norm (Manhattan) : {np.linalg.norm(v, 1):.4f}   = |3| + |4|")
print()
print("For our weights:")
print(f"  w = {w}")
print(f"  L2 norm: {np.linalg.norm(w, 2):.2f}")
print(f"  L1 norm: {np.linalg.norm(w, 1):.2f}")

show(pd.DataFrame([
    {"Norm": "L2 (square root of the sum of squares)", "Formula": "sqrt(sum(w^2))",
     "Where it's used": "Ridge regression: penalises large weights"},
    {"Norm": "L1 (sum of absolute values)", "Formula": "sum(|w|)",
     "Where it's used": "Lasso: pushes weights EXACTLY to zero"},
]))

show(pd.DataFrame([
    {"Concept": "Vector", "In code": "x = np.array([...])", "In ML": "One sample (one flat)"},
    {"Concept": "Matrix", "In code": "X.shape = (n, m)", "In ML": "n samples, m features"},
    {"Concept": "Dot product", "In code": "x @ w + b", "In ML": "ONE prediction: the most important operation"},
    {"Concept": "Matrix multiplication", "In code": "X @ w + b", "In ML": "ALL the predictions at once"},
    {"Concept": "The shape rule", "In code": "(n,m) @ (m,k) = (n,k)", "In ML": "Half of all mistakes live here"},
    {"Concept": "Transpose", "In code": "X.T", "In ML": "X.T @ X: the normal equation and PCA"},
    {"Concept": "Broadcasting", "In code": "X - X.mean(axis=0)", "In ML": "What's inside StandardScaler"},
    {"Concept": "L1 / L2 norm", "In code": "np.linalg.norm(w, 1/2)", "In ML": "Lasso and Ridge (Chapter 17)"},
]))