Las transformaciones lineales con matrices son la base geométrica que explica cómo una red neuronal deforma el espacio para separar datos. Aquí aprenderás a leer una matriz como un operador que rota, escala o inclina vectores, y a visualizarlo en Python con NumPy y Matplotlib. Es un recurso pensado para quienes vienen de fundamentos de álgebra lineal y quieren conectar la teoría con machine learning.

¿Qué significa que una matriz sea una transformación lineal?

Una matriz no es solo una tabla de números: es una máquina que toma todo el espacio vectorial y lo transforma. Esa intuición cambia la forma en que lees el álgebra lineal aplicada a deep learning.

La regla clave que viste en fundamentos sigue vigente: las columnas de una matriz indican dónde aterrizan los vectores de la base estándar después de aplicar la transformación [1:05]. Recuerda que i sombrerito vale (1,0) y j sombrerito vale (0,1).

Si tienes una matriz A con columnas (2,1) y (1,1), entonces el nuevo i es (2,1) y el nuevo j es (1,1). Con eso ya puedes anticipar cómo se deforma toda la cuadrícula del plano.

¿Cómo leo una matriz como transformación? Mira sus columnas. La primera columna es el destino del vector i, la segunda columna es el destino del vector j. Esas dos coordenadas definen toda la deformación del espacio.

¿Por qué importa esto en machine learning?

Cada capa de una red neuronal es, en esencia, una matriz de pesos [1:55]. Cuando los datos pasan por la capa, el modelo aplica una transformación lineal que estira, contrae o rota el espacio.

El entrenamiento busca la secuencia exacta de transformaciones que coloque las clases (por ejemplo, perros y gatos en una tarea de clasificación) en regiones separadas, donde una simple línea o plano pueda distinguirlas. Entender transformaciones es entender cómo piensa un modelo.

¿Cómo aplicar transformaciones a un vector con NumPy?

Vamos al código. Abre un notebook en Google Colab e importa las librerías base.

python import numpy as np import matplotlib.pyplot as plt

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

Ahora define tres matrices que representen tres efectos clásicos: rotación, escalado e inclinación [3:30].

python matriz_rotacion = np.array([[0, -1], [1, 0]])

matriz_escalado = np.array([[2, 0], [0, 0.5]])

matriz_inclinada = np.array([[1, 1], [0, 1]])

Lee las columnas de cada una y predice el efecto antes de ejecutar:

• La rotación envía i a (0,1) y j a (-1,0): gira 90 grados antihorario.
• El escalado duplica el eje X y reduce a la mitad el eje Y.
• La inclinación deja i fijo y empuja j hacia la derecha.

¿Cómo se multiplica una matriz por un vector?

Usa el producto punto de NumPy con np.dot o el operador @. Aplica cada matriz al mismo vector original [5:30]:

python v_rotado = matriz_rotacion @ v_original v_escalado = matriz_escalado @ v_original v_inclinado = matriz_inclinada @ v_original

print(v_rotado, v_escalado, v_inclinado)

Los resultados son contundentes: el vector (2,1) aterriza en (-1,2) tras la rotación, en (4, 0.5) tras el escalado y en (3,1) tras la inclinación.

¿Qué hace el producto punto entre matriz y vector? Reescribe el vector como combinación lineal de las columnas de la matriz. El resultado es la nueva posición del vector después de aplicar la transformación.

¿Cómo componer varias transformaciones en una sola matriz?

La composición de transformaciones se construye multiplicando matrices, y se lee de derecha a izquierda [6:45]. Si quieres rotar primero, luego escalar y al final inclinar, escribes:

python compuesta = matriz_inclinada @ matriz_escalado @ matriz_rotacion v_compuesto = compuesta @ v_original

Esa única matriz compuesta ya contiene los tres efectos. Aplicada al vector (2,1), lo lleva a la coordenada (-1,1).

Este es exactamente el principio que usa una red neuronal cuando encadena capas: cada multiplicación es una transformación, y el conjunto define cómo se reorganiza el espacio de entrada hasta que las clases quedan separables.

¿Cómo visualizar las transformaciones con Matplotlib?

Usa plt.subplots para crear cuatro subgráficos en una sola figura y reutiliza una función que dibuje el vector original como línea entrecortada y el transformado con quiver [9:30].

python fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(24, 6)) fig.suptitle("Tipos de transformaciones lineales aplicadas a un vector")

def graficar_transformacion(ax, title, v_transformado): ax.plot([0, v_original[0]], [0, v_original[1]], "--", color="gray", label="vector original") ax.quiver(0, 0, v_transformado[0], v_transformado[1], angles="xy", scale_units="xy", scale=1, color="r", label="vector transformado") ax.set_title(title) ax.grid(True) ax.set_xlim(-3, 4) ax.set_ylim(-3, 4) ax.legend()

graficar_transformacion(ax1, "Rotación 90 grados", v_rotado) graficar_transformacion(ax2, "Escalado", v_escalado) graficar_transformacion(ax3, "Inclinación", v_inclinado) graficar_transformacion(ax4, "Composición", v_compuesto) plt.show()

En los cuatro paneles vas a ver el mismo vector fantasma y la flecha roja en su nueva posición. La rotación gira 90 grados antihorario, el escalado hace zoom asimétrico, la inclinación empuja a la derecha y la composición confirma el (-1,1) que imprimiste antes.

¿Qué viene después de las transformaciones lineales?

Ya viste que las matrices rotan, estiran e inclinan vectores. Pero existe una pregunta natural: ¿hay direcciones que una matriz no rota, solo estira? La respuesta es sí, y esos vectores especiales se llaman eigenvectores [14:20]. Son la puerta de entrada al eigenanálisis y a la estructura profunda de tus datos.

Reto rápido: crea tu propia matriz 2x2, aplícala al vector (2,1) y describe en una frase el efecto. Por ejemplo, mi matriz lo estiró en el eje X y lo encogió en el eje Y. Comparte tu resultado en los comentarios.