Matrices como Transformaciones Lineales

En la mayoría de las introducciones al álgebra lineal, las matrices se presentan como simples arreglos de números utilizados para resolver sistemas de ecuaciones.

Sin embargo, esta interpretación es limitada. Para avanzar en machine learning y ciencia de datos, necesitas adoptar una visión más potente: una matriz es una transformación lineal.

¿Qué es una transformación lineal?

Una transformación lineal es una función que toma un vector y lo convierte en otro vector, respetando dos propiedades clave:

• Aditividad: El vector de transformación \(T\) multiplicado por la suma de los vectores \(u\) y \(v\) es igual a la suma de la multiplicación del vector de transformación por cada vector.

$$T(u + v) = T(u) + T(v)$$

• Homogeneidad:
  $$T(\lambda v) = \lambda T(v) $$

En términos prácticos: es una forma estructurada de “mover” puntos en el espacio.

De puntos a vectores: el lenguaje correcto

En el plano 2D, cualquier punto puede representarse como un vector columna, por lo que en realidad no trabajamos con puntos sino con vectores.

$$
\begin{pmatrix}
x \
y
\end{pmatrix}
$$

La matriz como función

Considera la matriz:

$$M = \begin{pmatrix}3 & 1 \\ 1 & 2\end{pmatrix}$$

Y el vector que se está transformando:

$$v = \begin{pmatrix}1 \\ 1\end{pmatrix}$$

Multiplicamos:

$$
\begin{pmatrix}
3 & 1 \\
1 & 2
\end{pmatrix}
\begin{pmatrix}
1 \\
1
\end{pmatrix}
=
\begin{pmatrix}
3\cdot1 + 1\cdot1 \\
1\cdot1 + 2\cdot1
\end{pmatrix}
=
\begin{pmatrix}
4 \\
3
\end{pmatrix}
$$

Resultado: el vector (1,1) se transforma en (4,3)

Qué significa geométricamente

La matriz hace esto:

• ( (1,0) \rightarrow (3,1) )
• ( (0,1) \rightarrow (1,2) )

👉 Es decir:

• Estira
• Inclina (shear)
• Mezcla las coordenadas

Y el cuadrado unidad:

• (0,0), (1,0), (0,1), (1,1)

se convierte en un paralelogramo

📊 3. Código: PRIMERA gráfica (espacio original)

import numpy as np
import matplotlib.pyplot as plt

# Cuadrado original
square = np.array([
    [0, 0],
    [1, 0],
    [1, 1],
    [0, 1],
    [0, 0]
])

plt.figure()

# Dibujar cuadrado
plt.plot(square[:,0], square[:,1], marker='o')

# Configuración
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.axhline(0)
plt.axvline(0)
plt.grid()

plt.title("Espacio original")

plt.show()

📊 4. Código: SEGUNDA gráfica (espacio transformado)

import numpy as np
import matplotlib.pyplot as plt

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

# Cuadrado original
square = np.array([
    [0, 0],
    [1, 0],
    [1, 1],
    [0, 1],
    [0, 0]
])

# Transformar puntos
square_trans = (A @ square.T).T

plt.figure()

# Dibujar cuadrado transformado
plt.plot(square_trans[:,0], square_trans[:,1], marker='o')

# Configuración
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.axhline(0)
plt.axvline(0)
plt.grid()

plt.title("Espacio transformado")

plt.show()

🔍 5. Qué debes observar (esto es lo importante)

Cuando ejecutes ambas gráficas:

📌 Gráfica 1 (original)

• Ves un cuadrado perfecto
• Base estándar: ( (1,0), (0,1) )

📌 Gráfica 2 (transformada)

• El cuadrado se convierte en un paralelogramo
• Los lados ya no son perpendiculares
• El espacio ha sido deformado

🚀 6. Insight clave (nivel data science)

Esto que acabas de hacer es EXACTAMENTE lo que ocurre en:

• PCA → rotación + escalado del espacio
• redes neuronales → transformación de features
• embeddings → cambio de base

🧠 7. Lectura avanzada de la matriz

Las columnas te dicen TODO:

[
A =
\begin{pmatrix}
\color{blue}{3} & \color{orange}{1} \
\color{blue}{1} & \color{orange}{2}
\end{pmatrix}
]

• columna 1 → destino de (1,0) → (3,1)
• columna 2 → destino de (0,1) → (1,2)

👉 El paralelogramo se construye con esas dos direcciones.

✅ 8. Si quieres subir un nivel más

El siguiente paso natural (muy importante) es:

• dibujar también la rejilla completa
• ver cómo se deforma TODO el plano

Eso ya conecta directamente con:

• determinante (área)
• eigenvectores
• PCA

Si quieres, en el siguiente paso te hago una versión PRO donde ves la malla deformándose (eso es lo que usan en cursos avanzados de ML).

Considera la matriz:

$$
A =
\begin{pmatrix}
3 & 1 \
1 & 2
\end{pmatrix}
$$

Esta matriz define una transformación que actúa sobre cualquier vector:

$$
T(\mathbf{v}) = A \cdot \mathbf{v}
$$

Es decir:

$$\begin{pmatrix}3 & 1 \ 1 & 2\end{pmatrix}\begin{pmatrix}x \ y\end{pmatrix}$$

El resultado es otro vector en el plano transformado.

import numpy as np
import matplotlib.pyplot as plt

# Cuadrado original
square = np.array([
    [0, 0],
    [1, 0],
    [1, 1],
    [0, 1],
    [0, 0]
])

plt.figure()

# Dibujar cuadrado
plt.plot(square[:,0], square[:,1], marker='o', color='darkblue')

# Configuración
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.axhline(0)
plt.axvline(0)
plt.grid()

plt.title("Espacio original")

plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Cuadrado original
square = np.array([
    [0, 0],
    [1, 0],
    [1, 1],
    [0, 1],
    [0, 0]
])

plt.figure()

# Dibujar cuadrado
plt.plot(square[:,0], square[:,1], marker='o', color='darkblue')

# Configuración
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.axhline(0)
plt.axvline(0)
plt.grid()

plt.title("Espacio original")

plt.show()

Matriz transformada

import numpy as np
import matplotlib.pyplot as plt

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

# Cuadrado original
square = np.array([
    [0, 0],
    [1, 0],
    [1, 1],
    [0, 1],
    [0, 0]
])

# Transformar puntos
square_trans = (A @ square.T).T

plt.figure()

# Dibujar cuadrado transformado
plt.plot(square_trans[:,0], square_trans[:,1], marker='o')

# Configuración
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.axhline(0)
plt.axvline(0)
plt.grid()

plt.title("Espacio transformado")

plt.show()

import numpy as np
import matplotlib.pyplot as plt

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

# Cuadrado original
square = np.array([
    [0, 0],
    [1, 0],
    [1, 1],
    [0, 1],
    [0, 0]
])

# Transformar puntos
square_trans = (A @ square.T).T

plt.figure()

# Dibujar cuadrado transformado
plt.plot(square_trans[:,0], square_trans[:,1], marker='o')

# Configuración
plt.xlim(-1, 5)
plt.ylim(-1, 5)
plt.axhline(0)
plt.axvline(0)
plt.grid()

plt.title("Espacio transformado")

plt.show()

4. Interpretación geométrica (clave para ML)

Aquí ocurre el cambio de paradigma:

La matriz no es solo cálculo → es una deformación del espacio.

Cuando aplicas una matriz:

• Las rectas siguen siendo rectas
• El origen permanece fijo
• Las proporciones se conservan (linealidad)

Pero:

• El espacio puede estirarse
• Puede comprimirse
• Puede rotarse
• Puede inclinarse (shear)

5. ¿Qué le hace la matriz al espacio?

Para entender completamente una transformación, no necesitas analizar todos los vectores.

Solo necesitas observar qué ocurre con los vectores base:

[
\mathbf{e_1} =
\begin{pmatrix}
1 \
0
\end{pmatrix}
,\quad
\mathbf{e_2} =
\begin{pmatrix}
0 \
1
\end{pmatrix}
]

Aplicamos la matriz:

[
A \cdot \mathbf{e_1} =
\begin{pmatrix}
3 \
1
\end{pmatrix}
,\quad
A \cdot \mathbf{e_2} =
\begin{pmatrix}
1 \
2
\end{pmatrix}
]

Interpretación:

Las columnas de la matriz son el destino de los vectores base.

Esto es fundamental en ciencia de datos.

6. Idea clave (muy importante)

Una matriz está completamente definida por cómo transforma los vectores base.

Esto implica:

• La primera columna → dónde va ( (1,0) )
• La segunda columna → dónde va ( (0,1) )

Y cualquier otro vector es combinación de estos.

7. Ejemplo conceptual

Si tienes un vector:

[
\begin{pmatrix}
x \
y
\end{pmatrix}
]

Puedes verlo como:

[
x \cdot \mathbf{e_1} + y \cdot \mathbf{e_2}
]

Entonces la transformación es:

[
T(x,y) = x \cdot T(\mathbf{e_1}) + y \cdot T(\mathbf{e_2})
]

Esto explica por qué la multiplicación matricial funciona como funciona.

8. Conexión directa con Data Science

Esta interpretación no es teórica: es la base de muchos algoritmos.

🔹 1. Transformaciones de features

En preprocessing:

• Escalado
• Rotación de variables
• Proyecciones

Todo son matrices aplicadas a vectores de datos.

🔹 2. PCA (Análisis de Componentes Principales)

PCA busca una transformación lineal que:

• Reoriente los datos
• Maximice la varianza en nuevos ejes

Eso es literalmente aplicar una matriz.

🔹 3. Redes neuronales

Cada capa de una red hace:

[
z = W x + b
]

Donde:

• (W) es una matriz → transformación lineal
• (b) es traslación (no linealidad adicional)

🔹 4. Embeddings y espacios vectoriales

Transformaciones entre espacios:

• Word embeddings
• Representaciones latentes
• Reducción dimensional

Todo se basa en matrices como transformaciones.

9. Intuición operativa para el científico de datos

Cuando veas una matriz, deja de pensar:

❌ “tabla de números”

Empieza a pensar:

✅ “operador que deforma el espacio”

Y hazte siempre estas preguntas:

• ¿Está escalando?
• ¿Está rotando?
• ¿Está mezclando variables?
• ¿Está proyectando a otro espacio?

10. Resumen

• Una matriz es una función lineal
• Actúa sobre vectores → produce nuevos vectores
• Está definida por sus columnas
• Representa una transformación del espacio
• Es el núcleo matemático de muchos modelos en ML

11. Cierre conceptual

Si interiorizas esta idea:

“Multiplicar por una matriz es transformar el espacio”

entonces empiezas a entender realmente:

• cómo funcionan los modelos
• por qué ciertas técnicas funcionan
• y cómo diseñar transformaciones útiles en problemas reales

Si quieres, en el siguiente paso puedo convertir esta clase en:

• una versión con gráficos en Python (matplotlib)
• o una continuación con eigenvectores/eigenvalores (clave para PCA)