Cómo las matrices transforman vectores en Python

Comprender cómo una matriz de 2x2 rota, estira o deforma datos te da control sobre tus modelos. Aquí verás, paso a paso, cómo leer columnas como imágenes de la base estándar y cómo aplicar transformaciones en Google Colab con NumPy y Matplotlib para visualizar resultados claros y útiles.

Transformaciones lineales en NumPy y Matplotlib: rotación, escalado, inclinación y composición

¿Cómo se interpretan las matrices como transformaciones lineales?

Una matriz no es solo números: es un operador que transforma todo el espacio de vectores. La clave está en la base estándar. Las columnas de la matriz son las coordenadas donde aterrizan I sombrerito y J sombrerito tras la transformación. Si A = [[2, 1], [1, 1]], entonces I sombrerito → (2, 1) y J sombrerito → (1, 1). Con eso ya puedes anticipar cómo se deforma la cuadrícula completa.

• Habilidad: leer columnas como imágenes de la base estándar.
• Concepto: transformación lineal como rotación, escalado o cizalla (inclinación).
• Dato: cada capa de una red neuronal es una matriz de pesos que deforma el espacio para separar clases con fronteras simples.

¿Por qué esto importa en machine learning?

• El entrenamiento busca una secuencia de transformaciones que separen clases como perros y gatos en regiones distintas.
• Entender estas transformaciones es entender cómo “piensa” el modelo al rotar, estirar y contraer el espacio.

¿Qué implementamos en Google Colab con NumPy y Matplotlib?

Se parte de un vector original y tres matrices: una rotación 90° antihoraria, un escalado no uniforme y una inclinación a la derecha. Luego, se compone todo en una sola matriz para ver el efecto acumulado.

# Imports
import numpy as np
import matplotlib.pyplot as plt

# Vector original
V_original = np.array([2, 1])

# Matrices de transformación
matriz_rotacion = np.array([[0, -1],
                            [1,  0]])      # 90° a la izquierda

matriz_escalado = np.array([[2.0, 0.0],
                            [0.0, 0.5]])    # escala x2 en x y x0.5 en y

matriz_inclinada = np.array([[1, 1],
                             [0, 1]])       # inclinación (cizalla) a la derecha

# Aplicaciones
V_rotado    = matriz_rotacion @ V_original
V_escalado  = matriz_escalado @ V_original
V_inclinado = matriz_inclinada @ V_original

print(V_rotado)    # [-1  2]
print(V_escalado)  # [4.  0.5]
print(V_inclinado) # [3 1]

• Resultado clave: V_rotado → (-1, 2).
• Resultado clave: V_escalado → (4, 0.5).
• Resultado clave: V_inclinado → (3, 1).

¿Cómo graficar el vector original y transformado?

Se construye una función para trazar el vector original con línea gris entrecortada y su transformado como flecha roja usando quiver.

def graficar_transformaciones(ax, title, V_transformado):
    # Vector original (línea gris, origen 0,0)
    ax.plot([0, V_original[0]], [0, V_original[1]], "--", color="grey", label="Vector original")

    # Vector transformado (flecha roja)
    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()

# Lienzo con 4 subgráficos
fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(24, 6))
fig.suptitle('Tipos de transformaciones lineales aplicadas a un vector')

# Llamadas
graficar_transformaciones(ax1, 'Rotación 90 grados', V_rotado)
graficar_transformaciones(ax2, 'Escalado', V_escalado)
graficar_transformaciones(ax3, 'Inclinación', V_inclinado)

# Composición
matriz_compuesta = matriz_rotacion @ matriz_escalado @ matriz_inclinada
V_compuesto = matriz_compuesta @ V_original

graficar_transformaciones(ax4, 'Composición', V_compuesto)
plt.show()

• Se usa subplots con 1 fila y 4 columnas.
• Límites fijos en ejes para comparación consistente.
• Etiquetas y grilla para lectura clara.

¿Qué revela la composición de matrices en machine learning?

El orden de multiplicación importa. La transformación se lee de derecha a izquierda: primero rotación, luego escalado y al final inclinación. La matriz compuesta concentra el efecto total.

matriz_compuesta = matriz_rotacion @ matriz_escalado @ matriz_inclinada
V_compuesto = matriz_compuesta @ V_original
print(V_compuesto)  # [-1.  1.]

• Resultado clave: V_compuesto → (-1, 1).
• Idea central: la composición de transformaciones modela cómo una red va deformando el espacio capa a capa para separar clases con un plano o línea simples.

¿Qué desafío práctico puedes intentar?

• Crea una matriz 2x2 propia y multiplícala por [2, 1].
• Describe en una frase el efecto: qué rota, qué estira, qué contrae.
• Ejemplo de descripción: “mi matriz A lo estiró en x y lo encogió en y”.

¿Qué viene con eigenvectores y eigenanálisis?

• Sí existen direcciones especiales que no rotan: son los eigenvectores.
• Son clave para descubrir estructura profunda en los datos mediante eigenanálisis.

¿Ya probaste tu matriz 2x2 y el vector [2, 1]? Comparte tu resultado y la frase que describe el efecto en los comentarios.