Transformaciones en 2D con NumPy y Matplotlib

Comprende con claridad cómo una matriz actúa como operador lineal que rota, estira e inclina tus datos. Con NumPy y Matplotlib en Google Colab, verás cómo las columnas anticipan el efecto de la transformación y por qué el orden de la multiplicación de matrices importa en machine learning y deep learning.

¿Cómo pensar una matriz como operador en machine learning?

Una matriz no es solo una tabla: es un operador lineal que transforma todo el espacio de vectores. La clave está en la base estándar: î = (1, 0) y ĵ = (0, 1). Las columnas de la matriz indican a dónde van î y ĵ tras la transformación, y con eso se deforma toda la cuadrícula del plano.

• En A = [[2, 1], [1, 1]], î → (2, 1) y ĵ → (1, 1).
• Las transformaciones típicas: rotación, escalado e inclinación (shear).
• En redes neuronales, una capa es una matriz de pesos que deforma el espacio para separar clases con un plano simple.

¿Cómo implementar rotación, escalado e inclinación con NumPy y Matplotlib?

Ver el efecto numérico y visual refuerza la intuición geométrica. A continuación, el flujo reproducible en Colab.

¿Cómo definir el vector y las matrices en NumPy?

import numpy as np
import matplotlib.pyplot as plt

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

# Matrices 2x2
matriz_rotacion = np.array([[0, -1],
                            [1,  0]])         # rotación 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 (shear) hacia la derecha

¿Cómo aplicar las transformaciones y leer resultados?

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

print('v_rotado   =', v_rotado)     # [-1  2]
print('v_escalado =', v_escalado)   # [4.  0.5]
print('v_inclinado=', v_inclinado)  # [3 1]

• Rotación 90° antihoraria: (2, 1) → (−1, 2).
• Escalado: (2, 1) → (4, 0.5).
• Inclinación: (2, 1) → (3, 1).

¿Cómo componer transformaciones y visualizar con Matplotlib?

El orden importa: se aplica de derecha a izquierda. Si primero rotas, luego escalas y al final inclinas, la matriz compuesta es matriz_inclinada @ matriz_escalado @ matriz_rotacion.

# Composición: primero rotar, luego escalar, al final inclinar
compuesta = matriz_inclinada @ matriz_escalado @ matriz_rotacion
v_compuesto = compuesta @ v_original
print('v_compuesto =', v_compuesto)  # [-1.  1.]

Para visualizar con Matplotlib usando subplots y quiver:

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

def graficar_transformaciones(ax, title, v_transformado):
    # vector original (línea entrecortada)
    ax.plot([0, v_original[0]], [0, v_original[1]], '--', color='gray', label='vector original')
    # vector transformado (flecha)
    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_transformaciones(ax1, 'rotación 90°', v_rotado)
graficar_transformaciones(ax2, 'escalado', v_escalado)
graficar_transformaciones(ax3, 'inclinación', v_inclinado)
graficar_transformaciones(ax4, 'composición', v_compuesto)
plt.show()

• Uso de subplots para comparar efectos en un solo lienzo.
• Función auxiliar para evitar repetición de código.
• quiver para flechas, plot para el vector original como referencia.

¿Qué habilidades y conceptos clave se practican y qué sigue con eigenvectores?

Lo aprendido cimenta una intuición geométrica útil en modelos lineales y redes profundas, donde cada capa de pesos deforma el espacio para separar clases de forma más simple.

• Lectura de transformación desde las columnas de la matriz.
• Manejo de rotación, escalado e inclinación en 2D.
• Composición de matrices y orden derecha a izquierda.
• Visualización con Matplotlib: subplots, quiver, cuadrícula y límites.
• Pensamiento geométrico aplicado a machine learning y deep learning.

Existe una dirección especial que una matriz no rota, solo estira: los eigenvectores. Son esenciales para revelar estructura en los datos mediante eigenanálisis. Muy pronto, se profundiza en ese análisis paso a paso.

¿Te animas a practicar? Crea una matriz 2x2 propia, aplícala al vector (2, 1) y describe en una frase el efecto geométrico. Comparte tu matriz, el resultado y tu interpretación en los comentarios.