Anexo · Álgebra lineal para Machine Learning (para novatos)¶

Anexo de apoyo. No es una unidad del curso ni sustituye a la lección 1.4 de NumPy (que enseña el manejo de arrays). Esta página explica qué significan los vectores, las matrices y sus operaciones, y por qué aparecen en cada modelo. Parte de cero: no hace falta haber dado álgebra lineal. Solo se asume saber crear arrays básicos en NumPy. Los ejemplos se ejecutan con uv run python (NumPy es dependencia del proyecto).

Contexto y motivación¶

Cuando un modelo te parezca "magia" o veas X @ w y te entre vértigo, vuelve aquí. La idea central son tres frases:

• Una tabla de datos ES una matriz.
• Una fila de esa tabla ES un vector (una observación, sus características).
• Un modelo lineal ES una multiplicación X @ w.

Entender esas tres frases te quita el "velo" de la mayor parte del Machine Learning: la regresión lineal, la regresión logística y, en esencia, una neurona artificial, funcionan sumando características ponderadas. El álgebra lineal es el lenguaje de esa suma.

Objetivos observables¶

Al terminar podrás...

• Explicar qué es un vector y qué es su dimensión.
• Representar una tabla como matriz X y dar su forma (m, n).
• Sumar vectores, multiplicarlos por un escalar y calcular el producto punto, e interpretar cada resultado.
• Calcular X @ w y justificar por qué el resultado es un vector de m predicciones.
• Explicar qué son la transpuesta, la identidad y la inversa, y para qué se usan.
• Calcular la norma de un vector, normalizarlo y explicar por qué importa en ML.
• Comparar dos vectores con la similitud coseno.
• Ajustar unos pesos con la ecuación normal y explicar cuándo falla.
• Interpretar XᵀX como la relación entre características y detectar colinealidad.
• Explicar qué son los autovalores/autovectores y su papel en PCA.
• Detectar el error de "dimensiones que no coinciden" y corregirlo.
• Interpretar la predicción de un modelo lineal a partir de los pesos w.

Cómo comprobarlo: al final hay una práctica de transferencia; si la resuelves, has conseguido todos los objetivos.

Vocabulario mínimo¶

Prerrequisitos¶

• Saber sumar y multiplicar números.
• Crear arrays en NumPy (np.array, .shape) — lección 1.4.
• No hace falta haber dado álgebra lineal.
• Trae la intuición de una tabla: filas = casos u observaciones, columnas = características.

1. Del número al vector¶

En ML, un dato aislado es un escalar: un solo número. Pero una observación normalmente tiene varias características a la vez. Para guardarlas en orden usamos un vector: una lista de números con un orden fijo.

Ejemplo. Una vivienda descrita por tres números: superficie, habitaciones y antigüedad.

import numpy as np

vivienda = np.array([80, 3, 10])   # m², habitaciones, años
print(vivienda.shape)              # cuántos elementos tiene

Salida esperada:

(3,)

(3,) es la forma del vector: tiene dimensión 3. El orden importa: la componente 0 es la superficie, la 1 son las habitaciones y la 2 la antigüedad. Si cambias el orden, cambias el dato.

¿Y por qué decimos "vector"? Porque un par de números se puede ver como un punto (o una flecha desde el origen) en el plano, y una terna como un punto en el espacio. Pero en ML casi nunca hay 2 o 3 características: hay 10, 100 o 1000. Entonces no intentes "ver" el espacio; quédate con la regla práctica: un vector es una lista de números en un orden fijo.

2. Sumar y escalar: la combinación lineal¶

Dos operaciones con vectores:

• Sumar (o restar): se hace componente a componente.
• Multiplicar por un escalar: se multiplica cada componente por ese número (alarga, encoge o invierte si es negativo).

import numpy as np

v1 = np.array([80, 3, 10])         # vivienda A
v2 = np.array([60, 2, 5])          # vivienda B

# Combinación lineal: 70% de A y 30% de B
combinacion = 0.7 * v1 + 0.3 * v2
print(combinacion)

Salida esperada:

[74.   2.7  8.5]

La combinación lineal es la operación estrella del ML. Un modelo lineal calcula una suma ponderada de las características (una combinación lineal) y una neurona artificial hace exactamente eso y luego aplica una función de activación. Por eso conviene familiarizarse con la expresión a₁·v₁ + a₂·v₂ + … + aₖ·vₖ.

3. El producto punto: la predicción de un caso¶

El producto punto (o producto escalar) de dos vectores es la suma de los productos de sus componentes, y da un único número:

w · x = w₁·x₁ + w₂·x₂ + … + wₙ·xₙ

Es la predicción de un modelo lineal para una observación. Si x son las características y w los pesos aprendidos, entonces:

predicción = w · x + sesgo

import numpy as np

x = np.array([80, 3, 10])          # una vivienda
w = np.array([0.1, 50.0, 1.5])     # pesos del modelo
sesgo = 5.0

prediccion = np.dot(w, x) + sesgo
print(prediccion)

Salida esperada:

178.0

Compruébalo a mano: 0.1·80 + 50·3 + 1.5·10 = 8 + 150 + 15 = 173, y 173 + 5 = 178.

Interpretación geométrica (breve). El producto punto mide cuánto va un vector en la dirección del otro:

• Si los vectores apuntan igual → el resultado es grande y positivo.
• Si son perpendiculares → el resultado es 0.
• Si apuntan en sentido contrario → negativo.

Eso lo convierte en una medida de alineación o similitud: es la base de la similitud del coseno (que normaliza por las longitudes) y aparece en la correlación. En ML lo verás en recomendación, recuperación de texto y en muchas métricas.

4. La norma: tamaño, distancia y normalización¶

El producto punto medía en qué dirección va un vector respecto a otro. Ahora queremos medir cuánto mide un vector. Su norma (norma euclídea, o norma 2) es la raíz cuadrada de la suma de sus componentes al cuadrado:

‖x‖ = √(x₁² + x₂² + … + xₙ²)

Es la longitud de la flecha. En dos dimensiones, la longitud de (3, 4) es √(9 + 16) = 5.

import numpy as np

x = np.array([3.0, 4.0])
print(np.linalg.norm(x))          # longitud
print(x / np.linalg.norm(x))      # vector unitario (longitud 1)

Salida esperada:

5.0
[0.6 0.8]

• Distancia entre dos vectores: la norma de su diferencia, ‖a - b‖.
• Vector unitario: dividir entre la norma; mantiene la dirección y pasa a medir 1. Normalizar una característica es un paso parecido (dividir entre su desviación típica) para que ninguna domine a las demás.

¿Por qué importa en ML? Porque gran parte de las métricas son normas:

• El RMSE es la norma del vector de errores dividida por √m: ‖y - ŷ‖ / √m.
• Normalizar características evita que una variable con valores enormes (los m²) domine a otra con valores pequeños (los años) cuando las sumamos.
• La norma aparece en la regularización: penalizamos ‖w‖ (Ridge/Lasso).

Nota. Hablamos de la norma más habitual, la "norma 2". Hay otras (norma 1, norma ∞), pero la que usarás casi siempre en ML es esta.

5. Similitud coseno: ¿qué tan parecidos son dos vectores?¶

El producto punto medía alineación, pero le afectaba el tamaño de los vectores. Para comparar solo la dirección (y no la magnitud), dividimos entre las normas:

cos(a, b) = (a · b) / (‖a‖ · ‖b‖)

El resultado va de -1 a 1: 1 si apuntan igual, 0 si son perpendiculares y -1 si apuntan en sentido contrario.

import numpy as np

a = np.array([1.0, 2.0, 3.0])
b = np.array([4.0, 5.0, 6.0])

cos = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
print(np.round(cos, 4))

Salida esperada:

0.9746

Como los dos vectores apuntan "bastante en la misma dirección", la similitud es alta (cerca de 1). Esto es exactamente lo que se usa para comparar embeddings: en recomendadores, búsqueda semántica y RAG se representan textos como vectores y se ordenan por similitud coseno.

Conexión con el curso. En Python puedes usar from sklearn.metrics.pairwise import cosine_similarity, que hace este cálculo para todas las parejas de una vez.

6. La tabla de datos es una matriz¶

Apila varias filas (observaciones) y obtienes una matriz: una tabla de números con filas y columnas. En ML la llamamos X y su forma es (m, n), donde:

• m = número de observaciones (filas);
• n = número de características (columnas).

import numpy as np

X = np.array([
    [80, 3, 10],     # vivienda 1
    [60, 2, 5],      # vivienda 2
    [120, 4, 2],     # vivienda 3
    [75, 3, 20],     # vivienda 4
    [90, 3, 8],      # vivienda 5
])
print(X.shape)

Salida esperada:

(5, 3)

Léelo como "5 observaciones, 3 características". X[i, j] es el valor de la característica j de la observación i. La columna j son todos los valores de una característica; la fila i es un vector (una observación).

Notación del curso. Cuando aparezca X (mayúscula) y y (minúscula), X es la matriz de características y y es el objetivo (lo que queremos predecir). y suele ser un vector (una columna), no una matriz.

7. Producto matriz-vector: predecir todas las observaciones¶

La regla del producto matriz-vector:

(m × n) @ (n)  →  (m)

Cada elemento del resultado es el producto punto de una fila de X con el vector w. Es decir, X @ w calcula la predicción de cada observación, todas a la vez. Por eso aparece constantemente en el código de ML.

import numpy as np

X = np.array([
    [80, 3, 10],
    [60, 2, 5],
    [120, 4, 2],
    [75, 3, 20],
    [90, 3, 8],
])
w = np.array([0.1, 50.0, 1.5])
sesgo = 5.0

y_hat = X @ w + sesgo
print(y_hat)
print(y_hat.shape)

Salida esperada:

[178.  118.5 220.  192.5 176. ]
(5,)

Mira lo que ha pasado: como X tiene 5 filas y w tiene 3 componentes, el resultado es un vector de 5 predicciones, una por vivienda. El + sesgo suma el mismo número a todas (es un "empujón" constante, el término independiente del modelo).

Regla práctica para las dimensiones: las columnas de la matriz (el número n) deben coincidir con la longitud del vector w (n). Si no coinciden, NumPy lanza un error:

X @ np.array([0.1, 50.0])   # ERROR: X tiene 3 columnas, w tiene 2

Salida esperada (error):

ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0

Consejo. Siempre que te salga ese error, escribe antes print(X.shape) y print(w.shape). El problema, casi siempre, es que las dimensiones internas no coinciden.

8. Matriz por matriz, identidad e inversa¶

8.1 Producto matriz-matriz¶

(m × n) @ (n × p)  →  (m × p)

Cada celda (i, j) es el producto punto de la fila i de la primera por la columna j de la segunda. Las dimensiones internas (n) deben coincidir; el resultado tiene las dimensiones externas (m y p). El orden importa: A @ B no es lo mismo que B @ A.

8.2 De una columna de pesos a una capa de neuronas¶

Hasta ahora multiplicábamos X (m observaciones × n características) por un vector w (n pesos) y obteníamos m predicciones. Pero un modelo puede tener varias salidas: por ejemplo, una red de 2 neuronas usa una matriz de pesos W de forma (n, 2). El resultado X @ W es una matriz (m, 2): una columna por cada neurona.

import numpy as np

X = np.array([[1, 0],
              [0, 1],
              [1, 1]], dtype=float)
W = np.array([[2., -1.],
              [0.5, 3.]])
b = np.array([0., 1.])       # un sesgo por cada salida

Z = X @ W + b
print(Z.shape)
print(Z)

Salida esperada:

(3, 2)
[[2.  0. ]
 [0.5 4. ]
 [2.5 3. ]]

Z tiene una fila por observación y una columna por neurona. Cada elemento es un producto punto de una fila de X con una columna de W, más su sesgo. Si luego aplicas una función de activación (por ejemplo, la sigmoide en regresión logística) a Z, obtienes la salida de la capa. Esta es la operación central de una red neuronal: Z = X @ W + b.

8.3 Identidad¶

La matriz identidad I es la que no cambia nada: I @ A = A. Es el "1" de las matrices.

import numpy as np

A = np.array([[2., 1.],
              [1., 3.]])
I = np.eye(2)
print(I)
print(I @ A)      # devuelve A

Salida esperada:

[[1. 0.]
 [0. 1.]]
[[2. 1.]
 [1. 3.]]

8.4 Inversa y resolver sistemas¶

Si existe una matriz A⁻¹ tal que A @ A⁻¹ = I, se llama inversa. Sirve para resolver sistemas de ecuaciones: la ecuación A·x = b se despeja como x = A⁻¹·b. En NumPy se usa np.linalg.solve, más estable y rápido que calcular la inversa a mano.

import numpy as np

A = np.array([[2., 1.],
              [1., 3.]])
b = np.array([9., 8.])

x = np.linalg.solve(A, b)
print(x)
print(A @ x)      # comprobación: debe dar b

Salida esperada:

[3.8 1.4]
[9. 8.]

¿Y esto para qué en ML? La ecuación A·x = b con su solución x = A⁻¹·b es exactamente la lógica de la ecuación normal de la regresión lineal ((XᵀX)w = Xᵀy), que desarrollamos a fondo en la sección 9. Por ahora quédate con la idea: "despejar" los pesos con álgebra lineal, usando una transposición, un producto de matrices y una inversa.

9. La ecuación normal: ajustar un modelo con álgebra lineal¶

La regresión lineal busca los pesos w que hacen que X @ w se parezca lo más posible a y. El criterio habitual es minimizar la suma de los errores al cuadrado, es decir, minimizar ‖y - X·w‖². Resulta que eso se resuelve "despejando" con álgebra lineal, y la solución se llama ecuación normal:

w = (XᵀX)⁻¹ Xᵀ y

Para que la fórmula funcione, X debe incluir una columna de 1s (que hace de intercept o sesgo). Veámoslo con un caso exacto (sin ruido) para que el resultado salga limpio.

import numpy as np

x = np.array([1., 2., 3., 4.])        # una característica
y = np.array([3., 5., 7., 9.])        # objetivo (relación y = 2x + 1)
X = np.column_stack([np.ones(4), x])  # añade la columna de 1s (intercept)
print(X.shape)

# Ecuación normal
w = np.linalg.inv(X.T @ X) @ X.T @ y
print(w)

# El método "robusto" de NumPy (el que usarías en la práctica)
print(np.linalg.lstsq(X, y, rcond=None)[0])

Salida esperada:

(4, 2)
[1. 2.]
[1. 2.]

w = [1, 2] significa: intercept 1 y pendiente 2 (la recta y = 2x + 1). Ambos métodos coinciden. np.linalg.lstsq es el que usarías en la práctica, porque es más estable numéricamente.

10. ¿Qué guarda XᵀX? Matriz de Gram, covarianza y correlación¶

XᵀX nos dice cómo se relacionan las columnas (las características) entre sí. Su entrada (i, j) es el producto punto de la columna i con la columna j, es decir, la suma sobre las observaciones de caract_i · caract_j. Es simétrica. Se llama matriz de Gram.

Si además centramos cada columna (le restamos su media) y la dividimos por la desviación típica, obtenemos la matriz de correlación, acotada entre -1 y 1 y mucho más fácil de interpretar.

import numpy as np

X = np.array([
    [80, 3, 10],
    [60, 2, 5],
    [120, 4, 2],
    [75, 3, 20],
    [90, 3, 8],
], dtype=float)

print(X.T @ X)                        # matriz de Gram (3x3)
print(np.round(np.corrcoef(X.T), 2))  # matriz de correlación

Salida esperada:

[[38125.  1335.  3560.]
 [ 1335.    47.   132.]
 [ 3560.   132.   593.]]
[[ 1.    0.95 -0.43]
 [ 0.95  1.   -0.15]
 [-0.43 -0.15  1.  ]]

Cómo leerlo. En la matriz de correlación, la diagonal es siempre 1 (una variable se correlaciona perfectamente consigo misma). Fuera de la diagonal, un valor alto y positivo indica que las dos características crecen juntas. Aquí superficie y habitaciones tienen 0.95: están muy correlacionadas, es decir, aportan información muy parecida. Eso es colinealidad: el modelo no sabe distinguir cuál manda y eso desestabiliza los coeficientes. Por eso el análisis exploratorio (EDA) siempre incluye esta matriz, y por eso el PCA (reducción de dimensionalidad) trabaja sobre ella.

11. Matrices como transformaciones¶

Una matriz no es solo una "tabla de números": también es una máquina que recibe un vector y devuelve otro. Eso es una transformación lineal: estira, encoge, rota o proyecta.

import numpy as np

# Estira el eje x y encoge el eje y
S = np.array([[2., 0.],
              [0., 0.5]])
v = np.array([1., 1.])

print(S @ v)

Salida esperada:

[2.  0.5]

El vector (1, 1) se convierte en (2, 0.5): la componente x se duplicó y la y se redujo a la mitad. Aplicar varias transformaciones seguidas equivale a multiplicar sus matrices (y el orden importa). La identidad no cambia nada; la inversa deshace la transformación. En ML, cada capa lineal de una red es, en esencia, una transformación de este tipo.

12. Autovalores y autovectores: la intuición detrás del PCA¶

Algunos vectores, al aplicar una matriz, solo se escalan pero no giran: salen en la misma dirección que entraron, multiplicados por un número. Esos son los autovectores, y ese número el autovalor:

A v = λ v

• El autovector v define una dirección "especial" de la matriz.
• El autovalor λ dice cuánto se estira en esa dirección.
• Para matrices simétricas (como la de covarianza), los autovalores son reales y los autovectores perpendiculares.

import numpy as np

A = np.array([[2., 1.],
              [1., 2.]])

valores, vectores = np.linalg.eigh(A)
print(np.round(valores, 6))
print(np.round(np.abs(vectores), 6))

Salida esperada:

[1. 3.]
[[0.707107 0.707107]
 [0.707107 0.707107]]

np.linalg.eigh devuelve los autovalores ordenados de menor a mayor: aquí 1 y 3. El signo de cada autovector es arbitrario: v y -v representan la misma dirección. Por eso mostramos abs(vectores) para que la salida sea estable. La dirección con mayor autovalor (la de (1, 1)) es donde la matriz más "estira".

13. Independencia lineal y rango¶

Un conjunto de vectores es linealmente independiente si ninguno puede escribirse como combinación de los demás. Cuando dos características son una "combinación" la una de la otra (por ejemplo, siempre habitaciones = 2 · camas), aportan la misma información y hay colinealidad.

El rango de una matriz es el número de filas o columnas independientes; en cierto sentido, la "dimensión real" de los datos.

import numpy as np

A = np.array([[1., 2.],
              [2., 4.]])   # la 2ª fila es el doble de la 1ª
B = np.array([[1., 2.],
              [3., 4.]])

print(np.linalg.matrix_rank(A))   # 1
print(np.linalg.matrix_rank(B))   # 2

Salida esperada:

1
2

A tiene rango 1 (una fila es múltiplo de la otra), luego AᵀA sería singular y la ecuación normal fallaría; B tiene rango 2. La regla práctica para que el problema esté bien planteado: tener más observaciones que características (m > n) y características no colineales. Esto explica por qué molesta una característica redundante y por qué la regularización es tan útil.

Errores frecuentes¶

Ejemplo guiado completo¶

Pongamos todo junto en una mini regresión lineal "a mano":

import numpy as np

# Tabla de datos: X (5 viviendas, 3 características)
X = np.array([
    [80, 3, 10],
    [60, 2, 5],
    [120, 4, 2],
    [75, 3, 20],
    [90, 3, 8],
])

# Pesos aprendidos (supongamos que el modelo ya los ha calculado)
w = np.array([0.1, 50.0, 1.5])
b = 5.0

# Predicción de todas las viviendas a la vez
y_hat = X @ w + b

# La primera predicción a mano, para verificar
primera = np.dot(X[0], w) + b

print("Predicciones:", y_hat)
print("Primera a mano:", primera)
print("Coinciden:", np.isclose(y_hat[0], primera))

Salida esperada:

Predicciones: [178.  118.5 220.  192.5 176. ]
Primera a mano: 178.0
Coinciden: True

Lectura del resultado. El vector y_hat tiene un número por cada vivienda. El valor 178.0 corresponde a la primera fila (80 m², 3 habitaciones, 10 años): contribuyen 8 (superficie), 150 (habitaciones) y 15 (antigüedad), más un sesgo de 5. Compara con el resto: a más metros y más habitaciones, mayor predicción, aunque la antigüedad y otros factores matizan. Y esto es exactamente lo que hace la regresión lineal (y, en esencia, una neurona).

Práctica de transferencia¶

Resuelve esto antes de mirar la solución:

1. Dada X = np.array([[1, 2], [3, 4]]), ¿cuál es su forma? ¿Y la de X.T?
2. Calcula np.dot([1, 2, 3], [4, 5, 6]) a mano. ¿Qué número sale?
3. Si X tiene forma (4, 6) y w tiene (6,), ¿qué forma tiene X @ w? ¿Qué representa cada elemento?
4. Con A = [[2, 0], [0, 3]], ¿cuál es la inversa? Compruébala con np.linalg.inv(A).
5. Calcula la norma de [3, 4] y el vector unitario correspondiente.
6. ¿Cuál es la similitud coseno entre [1, 0] y [0, 1]? ¿Y entre [1, 0] y [2, 0]?
7. Si X tiene forma (m, n), ¿qué forma tiene X.T @ X? ¿Y X @ X.T?
8. Con A = [[2, 1], [1, 2]], ¿cuáles son sus autovalores? ¿Con qué dirección se asocia el mayor?

Soluciones (comprueba después):

1. (2, 2) y (2, 2) (la transpuesta de una 2×2 es 2×2).
2. 1·4 + 2·5 + 3·6 = 4 + 10 + 18 = 32.
3. (4,): un vector de 4 predicciones, una por cada observación.
4. np.linalg.inv(A) da [[0.5, 0], [0, 0.333...]].
5. Norma = 5; vector unitario = [0.6, 0.8].
6. Coseno entre [1, 0] y [0, 1] = 0 (perpendiculares); entre [1, 0] y [2, 0] = 1 (misma dirección).
7. X.T @ X es (n, n); X @ X.T es (m, m).
8. Autovalores 1 y 3; el mayor (3) corresponde a la dirección (1, 1).

Producto evaluable¶

En tu cuaderno marimo:

1. Crea la matriz X de un mini dataset de 4 viviendas con 2 características (por ejemplo, superficie y habitaciones).
2. Elige unos pesos w y un sesgo b razonables.
3. Calcula y_hat = X @ w + b.
4. En una celda de texto responde: ¿qué forma tiene y_hat y qué representa cada uno de sus elementos? Justifica usando los conceptos de producto punto y de filas-observaciones.

Resumen y referencia rápida¶

Las tres frases para llevarte: una tabla es una matriz; una fila es un vector; un modelo lineal es X @ w.

Referencias¶

• NumPy · matmul (operador @)
• NumPy · np.linalg.solve
• NumPy · np.linalg.norm
• NumPy · np.linalg.eigh
• scikit-learn · cosine_similarity
• 3Blue1Brown · Essence of linear algebra (capítulos 1–4)
• Strang · Linear Algebra (MIT OCW)