Autor: Fernando

El backsolving es un método para resolver sistemas de ecuaciones lineales una vez que ya hemos reducido el sistema a forma triangular superior mediante eliminación gaussiana (o cualquier otra técnica de factorización como LU).

Trabajamos el mismo problema del articulo anterior:

$$ M = \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix} , p = \begin{bmatrix} p_1 \\ p_2 \\ p_3 \end{bmatrix}, c = \begin{bmatrix} 34 \\ 69 \\ 48 \end{bmatrix} $$

Queremos resolver los precios \( (p) \) de cada producto. En este caso utilizaremos eliminación gaussiana y luego sustitución hacia atrás — eso es, reducir el sistema a triangular superior y luego encontrar las incógnitas empezando por la última.

Eliminación gaussiana (reducción hacia triangular superior)

Escribimos el sistema en sus ecuaciones explícitas (producto fila por columna):

$$ \begin{cases} 3p_1 + 6p_2 + 2p_3 = 34 \\ 10p_1 + 3p_2 + 8p_3 = 69 \\ 1p_1 + 7p_2 + 5p_3 = 48 \end{cases}$$

Paso 1 — usar la primera ecuación para eliminar \(p_1\) de las filas 2 y 3.

Despejamos \(p_1\) (temporalmente) o eliminamos directamente:

Multiplicador para la fila 2: \(\frac{10}{3}=2\).
Hacemos \(R_2 \leftarrow R_2 – 2R_1\):

• Columna 1: \(10 – 2\cdot 3 = 0\).
• Columna 2: \(3 – 2\cdot 6 = 3 – 12 = -9\).

Multiplicador para la fila 3: \(\frac{1}{3}\).
Hacemos \(R_3 \leftarrow R_3 – \frac{1}{3}R_1\).

Después de eliminar \(p_1\) en filas 2 y 3 (operaciones sobre las filas):

$$\begin{pmatrix}3 & 6 & 2 & | & 34\\0 & -17 & 4 & | & 1\\0 & \frac{4}{3} & \frac{13}{3} & | & \frac{76}{3} \end{pmatrix}$$

Nota: la fila 2 quedó con coeficiente (-17) en la columna de \(p_2\). La fila 3 tiene fracciones — eso es normal en eliminación.

Paso 2 — usar la fila 2 para eliminar la componente \(p_2\) de la fila 3.

Multiplicador para \(R_3\): \(f=\frac{\frac{4}{3}}{-17}=-\frac{4}{51}\).
Hacemos \(R_3 \leftarrow R_3 – f R_2 = R_3 + \frac{4}{51}R_2\).

Al realizar esa operación la segunda columna de \(R_3\) queda 0 y obtenemos una ecuación sólo en \(p_3\):

$$\begin{pmatrix}3 & 6 & 2 & | & 34 \\ 0 & -17 & 4 & | & 1 \\ 0 & 0 & \frac{241}{51} & | & \frac{1296}{51} \end{pmatrix}$$

Paso 3 — despejar \(p_3\) y luego usar sustitución hacia atrás.

De la tercera fila:

$$\frac{241}{51},p_3 = \frac{1296}{51} \quad\Rightarrow\quad p_3 = \frac{1296}{241}$$

Sustituyendo \(p_3\) en la segunda fila:

$$-17,p_2 + 4,p_3 = 1 \quad\Rightarrow\quad p_2 = \frac{1 – 4p_3}{-17}$$

Sustituyendo el valor numérico de \(p_3\) (o directamente resolviendo con las fracciones) se obtiene \(p_2=3\).

Finalmente sustituimos \(p_2\) y \(p_3\) en la primera ecuación para obtener (p_1), que da (p_1=2).

Conclusión del método manual (eliminación + sustitución):

$$\mathbf p = \begin{pmatrix}2 \\ 3 \\ 5\end{pmatrix}$$

¿Qué significa calcular la inversa \(M^{-1}\) y cómo se obtiene con matriz aumentada?

Otra forma más “directa” (y que explica el porqué de la eliminación) es calcular la inversa de \(M\). Si \(M\) es invertible entonces

$$\mathbf p = M^{-1}\mathbf c$$

Para encontrar \(M^{-1}\) se construye la matriz aumentada \([,M \mid I,]\) y se aplican operaciones elementales por filas hasta transformar el lado izquierdo en la identidad; entonces el lado derecho habrá quedado como \(M^{-1}\).

Verificaciones numéricas y redondeo

En la práctica, cuando calculas \(M^{-1}M\) en ordenador verás que los elementos fuera de la diagonal no son exactamente cero sino números muy pequeños (por ejemplo \(-5\times 10^{-17})\). Eso es error numérico de punto flotante. Si redondeas (por ejemplo a 10 decimales) obtendrás la matriz identidad exacta en la presentación.

Resumen conceptual

• Eliminación gaussiana: reduce el sistema a triangular superior (eliminación hacia adelante) y luego despeja las variables (sustitución hacia atrás).
• Inversa por matriz aumentada: hacer operaciones elementales sobre \([M\mid I]\) hasta convertir \(M\) en \(I\); lo que quede a la derecha será \(M^{-1}\).
• Comprobación: puedes verificar que \(M^{-1}\mathbf c = \mathbf p\) y \(M^{-1}M = I\) (hasta errores numéricos muy pequeños).

Código Python

import numpy as np

# Definición de la matriz y vectores (el sistema del ejemplo)
M = np.array([[3, 6, 2],
              [10, 3, 8],
              [1, 7, 5]], dtype=float)

c = np.array([34, 69, 48], dtype=float)

# 1) Resolver el sistema M p = c
p = np.linalg.solve(M, c)
print("Solución (np.linalg.solve):", p)

# 2) Calcular la inversa de M
M_inv = np.linalg.inv(M)
print("\nInversa M^{-1}:\n", M_inv)

# 3) Verificar que M^{-1} * c = p
p_from_inv = M_inv @ c
print("\nM^{-1} @ c =", p_from_inv)

# 4) Verificar que M_inv @ M ≈ I (mostramos la matriz y una versión redondeada)
I_approx = M_inv @ M
print("\nM^{-1} @ M (aprox):\n", I_approx)
print("\nM^{-1} @ M (redondeado a 10 decimales):\n", np.round(I_approx, 10))

import numpy as np

# Definición de la matriz y vectores (el sistema del ejemplo)
M = np.array([[3, 6, 2],
              [10, 3, 8],
              [1, 7, 5]], dtype=float)

c = np.array([34, 69, 48], dtype=float)

# 1) Resolver el sistema M p = c
p = np.linalg.solve(M, c)
print("Solución (np.linalg.solve):", p)

# 2) Calcular la inversa de M
M_inv = np.linalg.inv(M)
print("\nInversa M^{-1}:\n", M_inv)

# 3) Verificar que M^{-1} * c = p
p_from_inv = M_inv @ c
print("\nM^{-1} @ c =", p_from_inv)

# 4) Verificar que M_inv @ M ≈ I (mostramos la matriz y una versión redondeada)
I_approx = M_inv @ M
print("\nM^{-1} @ M (aprox):\n", I_approx)
print("\nM^{-1} @ M (redondeado a 10 decimales):\n", np.round(I_approx, 10))

Salida:

Solución (np.linalg.solve): [2. 3. 5.]

Inversa M^{-1}:
 [[ 0.17012448  0.06639004 -0.17427386]
 [ 0.17427386 -0.05394191  0.01659751]
 [-0.2780083   0.06224066  0.21161826]]

M^{-1} @ c = [2. 3. 5.]

M^{-1} @ M (aprox):
 [[ 1.00000000e+00  0.00000000e+00  0.00000000e+00]
 [-1.56125113e-16  1.00000000e+00 -5.55111512e-17]
 [ 5.55111512e-17  0.00000000e+00  1.00000000e+00]]

M^{-1} @ M (redondeado a 10 decimales):
 [[ 1.  0.  0.]
 [-0.  1. -0.]
 [ 0.  0.  1.]]

Solución (np.linalg.solve): [2. 3. 5.]

Inversa M^{-1}:
 [[ 0.17012448  0.06639004 -0.17427386]
 [ 0.17427386 -0.05394191  0.01659751]
 [-0.2780083   0.06224066  0.21161826]]

M^{-1} @ c = [2. 3. 5.]

M^{-1} @ M (aprox):
 [[ 1.00000000e+00  0.00000000e+00  0.00000000e+00]
 [-1.56125113e-16  1.00000000e+00 -5.55111512e-17]
 [ 5.55111512e-17  0.00000000e+00  1.00000000e+00]]

M^{-1} @ M (redondeado a 10 decimales):
 [[ 1.  0.  0.]
 [-0.  1. -0.]
 [ 0.  0.  1.]]

Qué observar al ejecutar:

• p debe salir como [2. 3. 5.].
• M_inv @ c debe coincidir con p (igual numéricamente, dentro de tolerancias de punto flotante).
• M_inv @ M será numéricamente la identidad; si ves valores muy pequeños fuera de la diagonal, es normal: redondea para comprobar que esos valores son efectivamente cero dentro de la precisión de la máquina.

Resumen

La eliminación y la inversa son dos caras de la misma moneda: la primera resuelve un sistema concreto, la segunda construye la “función inversa” que, aplicada a cualquier vector de costes, devolvería los precios.

En aplicaciones (ciencia de datos, econometría, ingeniería), normalmente no calculamos la inversa si solo queremos resolver un sistema: usamos solve (algoritmos de factorización) por razones de estabilidad numérica y eficiencia. Sin embargo, obtener la inversa es útil para entender conceptualmente la transformada inversa y para comprobaciones.

El Formato Matricial

La expresión general:

$$y=a_1​x_1​+a_2​x_2​+⋯+a_n​x_n​$$

Es el punto de partida que lleva directamente a la forma matricial de los sistemas lineales. El mismo sistema de ecuaciones de las frutas puede escribirse y resolverse en forma matricial. En la ciencia de datos los datasets son matrices, y resolver sistemas lineales ayuda a encontrar relaciones entre variables.

Partimos del sistema:

$$\begin{cases} 2x + 3y = 30 \\ x + y = 12 \end{cases}$$

En formato matricial:

$$\begin{bmatrix} 2 & 3 \\ 1 & 1 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} 30 \\ 12 \end{bmatrix}$$

Significado de las partes:

La forma vectorial compacta del sistema matricial se expresa como:

$$A\vec{x} = \vec{b}$$

Donde:

• \(A\) –> es la matriz de coeficientes
• \(\vec{x}\) –> es el vector de incógnitas
• \(\vec{b}\) –> es el vector de términos independientes

Por tanto:

$$A = \begin {bmatrix} 2 & 3 \\ 1 & 1 \end{bmatrix}, \vec{x} = \begin{bmatrix} x \\ y \end{bmatrix}, \vec{b} = \begin{bmatrix} 30 \\ 12 \end{bmatrix}$$

En ciencia de datos y machine learning esta forma es fundamental porque:

• Permite expresar relaciones entre miles de variables en una sola ecuación.
• Es la base de la regresión lineal, la reducción de dimensionalidad, y el entrenamiento de modelos.
• Toda la manipulación se hace con álgebra matricial, que es más eficiente computacionalmente.

Resolviendo problemas reales.

En artículos anteriores vimos operaciones sobre vectores y matrices desde la perspectiva matemática. Vamos a ver cómo esas mismas operaciones pueden resolver problemas reales, como descubrir cuánto cuesta cada producto de un supermercado.

Escenario

Volvemos a nuestro supermercado de frutas. Imaginemos que tenemos tres personas:
Bob, Alice y Tim, que han ido al supermercado y compraron manzanas, naranjas y peras. Podemos representar sus compras en una matriz \(M\):

$$M = \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix}$$

Cada fila representa una persona, y cada columna representa un producto:

El coste total

Sabemos cuánto pagó cada persona:

$$C =\begin{bmatrix} 34 \\ 69 \\ 48 \end{bmatrix}$$

Y queremos averiguar cuánto cuesta cada producto. Presentemos los importes que gasto cada uno en un vector que llamamos \( P \) , vector de precios:

$$P = \begin{bmatrix} p_1 \\ p_2 \\ p_3 \end{bmatrix} $$

Donde:

• \(p_1\) –> precio de la manzana
• \(p_2\) –> precio de la naranja
• \(p_3\) –> precio de la pera

Sabemos que:

$$M \cdot P = C$$

o, dicho en palabras: la cantidad comprada multiplicada por el precio unitario da el coste total.

Escribiendo las ecuaciones

Multiplicar la matriz \(M\) por el vector \(P\) nos da tres ecuaciones:

$$ \begin{cases} 3p_1 + 6p_2 + 2p_3 = 34 \\ 10p_1 + 3p_2 + 8p_3 = 69 \\ 1p_1 + 7p_2 + 5p_3 = 48 \end{cases}$$

Esto es un sistema de ecuaciones lineales con tres incógnitas: \( p_1, p_2, p_3 \).

Representar el sistema de ecuaciones en formato matricial:

$$ \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix} \cdot \begin{bmatrix} p_1 \\ p_2 \\ p_3 \end{bmatrix} = \begin{bmatrix} 34 \\ 69 \\ 48 \end{bmatrix} $$

Recordando, tenemos aqui:

• Matriz de coeficientes: contiene los números que multiplican a las variables (las cantidades de las frutas).
• Vector de incógnitas: las variables que queremos encontrar (precio de las frutas).
• Vector de resultados: los valores en el lado derecho (total de dinero gastado).

Cómo transformar el sistema para poder resolverlo

Hasta ahora has visto qué es un sistema de ecuaciones y cómo representarlo en forma matricial. Pero hay un problema práctico: tal como están escritas, las ecuaciones no siempre resultan fáciles de resolver.

En otros articulos hablamos de las caracteristicas del un sistema, como la singularidad. Aqui veremos como transformar el sistema sin cambiar su significado, haciendo mas simple su solucion.

Transformar sin perder información

Existe una serie de operaciones que podemos aplicar a las ecuaciones sin alterar sus soluciones:

• Intercambiar ecuaciones
• Multiplicar o dividir una ecuación por un número distinto de cero
• Sumar o restar ecuaciones entre sí

Estas operaciones son la base del Algoritmo de eliminación de Gauss. Su objetivo es reorganizar el sistema en una forma mucho más sencilla de interpretar.

Ejemplo conceptual del proceso

Partimos de un sistema cualquiera y aplicamos operaciones de fila para:

1. Elegir un elemento clave (pivote)
2. Convertir en cero todo lo que hay debajo
3. Repetir el proceso en las siguientes filas

El resultado es una matriz en la que la estructura del sistema se vuelve transparente.

Es como resolver un sistema de ecuaciones común por eliminación, pero aplicado directamente a los números de una matriz (llamada matriz de coeficientes). El objetivo es limpiar la matriz para que las respuestas sean evidentes.

Forma escalonada por filas (row echelon form).

Se consigue eliminando la información redundante y aislando la información útil. Cada paso reduce el sistema a algo más simple, manteniendo exactamente las mismas soluciones.

Una matriz está en esta forma cuando:

• Cada fila empieza más a la derecha que la anterior
• Debajo de cada elemento clave (pivote) hay ceros
• Las filas sin información (todos ceros) quedan al final

$$A = \begin{bmatrix}1 & * & * \\ 0 & 1 & * \\ 0 & 0 & 1 \end{bmatrix}$$

• Es útil porque te deja el sistema listo para “sustitución hacia atrás”.

Forma escalonada reducida: la solución directa

Si continúas el proceso un paso más, llegas a la forma escalonada reducida (reduced row echelon form) Aquí ocurre algo muy potente, en su columna solo hay ceros (arriba y abajo)

Cada pivote es 1

$$A = \begin{bmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix}$$

• Es el nivel máximo de limpieza.
• Aquí la solución es directa, cada fila te dice el valor de cada variable.

¿Qué pasa si el sistema es “Singular”?

A veces, al hacer la eliminación gaussiana, una fila completa se convierte en ceros \( 0 = 0 \)). Esto significa que:

• El sistema es singular (las ecuaciones eran dependientes o redundantes).
• En la matriz, verás un 0 en la diagonal principal en lugar de un 1.
• Esto indica que el sistema puede tener infinitas soluciones o ninguna.

Método de eliminación gaussiana

La eliminación gaussiana (o reducción de filas) es el proceso de manipular una matriz mediante operaciones matemáticas simples para simplificarla y resolver sistemas de ecuaciones.

Pasos en la solución.

1 – Crear la matriz aumentada:

$$
\left(
\begin{array}{ccc|c}
3 & 6 & 2 & 34 \\
10 & 3 & 8 & 69 \\
1 & 7 & 5 & 48
\end{array}
\right)
$$

2 – Elegir un buen pivote y hacer intercambio de filas.

En este ejemplo la fila 3 tiene coeficiente 1 y la cambiamos por la 1.

$$
F_1 \leftrightarrow F_3
$$

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 5 & 48 \\
10 & 3 & 8 & 69 \\
3 & 6 & 2 & 34
\end{array}
\right)
$$

3- Eliminación columna 1

Queremos eliminar las variables \( p_1 \) de las filas 2 y 3.

Buscamos eliminar las \(p_1\), lo primero es restar la fila 1 con la fila 2. Para esto hacemos una normalización de la fila dos, buscando que se elimine la variable. En notación de matrices se expone como:

$$
F_2 \leftarrow F_2 – 10F_1
$$

Lo que quiere decir es que la nueva fila \( F_2 \) será el resultado de la resta de la fila \( F_2 \) y la fila \( F_1 \) multiplicada por 10. Esto hace que se elimine \(p_1\) en la operación \(10p_1 – 10p_1\).

La segunda eliminación de la variable es creando una nueva fila 3 producto de la resta entre las filas \( F_3 \) y la \( F_1 \) multiplicando esta por 3.

$$
F_3 \leftarrow F_3 – 3F_1
$$

La matriz resultante es:

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 5 & 48 \\
0 & -67 & -42 & -411 \\
0 & -15 & -13 & -110
\end{array}
\right)
$$

4 – Normalización pivote 2

De la matriz actual buscamos reducir \(p_2\). Normalizamos la fila 2, dividiéndola entre 67, llevando \(p_2\) a 1.

$$
F_2 \leftarrow \frac{1}{-67}F_2
$$

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 5 & 48 \\
0 & 1 & \frac{42}{67} & \frac{411}{67} \\
0 & -15 & -13 & -110
\end{array}
\right)
$$

5 – Eliminación columna 2

Normalizamos la \(F_3\), dividiendo entre 15, y la restamos con \(F_2\) eliminando la variable.

$$
F_3 \leftarrow F_3 + 15F_2
$$

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 5 & 48 \\
0 & 1 & \frac{42}{67} & \frac{411}{67} \\
0 & 0 & \frac{-241}{67} & \frac{-1205}{67}
\end{array}
\right)
$$

6 – Normalización pivote 3

Multiplicamos \(F_3\) por \( \frac{-67}{241} \) para llevar \(p_3\) a 1.

$$
F_3 \leftarrow \frac{-67}{241}F_3
$$

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 5 & 48 \\
0 & 1 & \frac{42}{67} & \frac{411}{67} \\
0 & 0 & 1 & \frac{1205}{241}
\end{array}
\right)
$$

7 – Sustitución hacia atrás

Calcular el valor de \(p_3\).

$$
p_3 = \frac{1205}{241} = 5
$$

Sustituir \(p_3\) en \(F_2\)

$$
p_2 + \frac{42}{67} \cdot 5 = \frac{411}{67}
$$

$$
p_2 = 3
$$

Sustituir \(p_3\) y \(p_2\) en \(F_1\)

$$
p_1 + 7 \cdot 3 + 5 \cdot 5 = 48
$$

$$
p_1 = 2
$$

Resultado final

$$
\begin{cases}
p_1 = 2 \\
p_2 = 3 \\
p_3 = 5
\end{cases}
$$

Paso 4 — verificación (comprobación directa)

Multiplicamos la matriz por el vector de precios para ver si obtenemos los costes:

$$M = \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix}, p = \begin{bmatrix} 2 \\ 3 \\ 5 \end{bmatrix}$$

Producto \(Mp\):

• Fila 1: \( 3 \cdot 2 + 6 \cdot 3 + 2 \cdot 5 = 34\)
• Fila 2: \( 10 \cdot 2 + 3 \cdot 3 + 8 \cdot 5 = 69\)
• Fila 3: \( 1 \cdot 2 + 7 \cdot 3 + 5 \cdot 5 = 48\)

Método de Gauss-Jordan: llevar el sistema hasta la matriz identidad

Una vez hemos aplicado la sustitución hacia atrás y ya conocemos los valores de las variables, puede surgir una pregunta lógica: ¿Y si en lugar de calcular las variables “a mano”, dejamos la matriz ya resuelta automáticamente? Aquí es donde entra el método de Gauss-Jordan.

¿Qué aporta Gauss-Jordan?

El método de Gauss (el que hemos usado) termina en una matriz escalonada, y a partir de ahí necesitamos hacer sustitución hacia atrás. El método de Gauss-Jordan va un paso más allá. Sigue aplicando operaciones hasta convertir la matriz en la matriz identidad

💡 En ese momento:

• Ya no necesitas sustituir
• Los valores de las variables aparecen directamente en la última columna

¿Por qué es útil llegar a la identidad?

Porque transforma el sistema en algo trivial:

• Cada fila representa directamente una variable
• El sistema queda completamente desacoplado
• Es el método que se usa en:
  • cálculo matricial
  • inversa de matrices
  • implementaciones en programación

Continuamos el ejemplo

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 5 & 48 \\
0 & 1 & \frac{42}{67} & \frac{411}{67} \\
0 & 0 & 1 & \frac{1205}{241}
\end{array}
\right)
$$

Paso 1: Eliminar la columna 3 de la fila 2 usando la fila 3:

Operación \( F_2 \rightarrow F_2 – \frac{42}{67}F_3\)

• Columna 3:

$$ \frac{42}{67} – \frac{42}{67} \cdot 1 = 0$$

• Termino independiente:

$$ \frac{411}{67} – \frac{42}{67} \cdot 1 \frac{1205}{241}$$

$$ \frac{42 \cdot 1205}{67 \cdot 241} = \frac{50610}{16147}$$

Ahora llevamos \( \frac{411}{67}\) al mismo denominador:

$$ \frac{411}{67} = \frac{411 \cdot 241}{67 \cdot 241} = \frac{99051}{16147}$$

Restamos:

$$ \frac{99051}{16147} – \frac{50610}{16147} = \frac{48441}{16471} = 3$$

Nueva \(F_2\):

$$\left(\begin{array}{ccc|c}0 & 1 & 0 & 3 \end{array}\right)$$

Paso 2: eliminar la columna 3 de la fila 1 usando la fila 3

Operación \( F_1 \rightarrow F_1 – 5F_3\)

• Columna 3:

$$5 – 5 = 0$$

• Termino independiente:

$$ 48 – 5 \cdot \frac{1205}{241}$$

$$ 5 \cdot \frac{1205}{241} = \frac{6025}{241}$$

Pasamos 48 a fracción:

$$ 48 = \frac{11568}{241}$$

Restamos:

$$ \frac{11568}{241} – \frac{6025}{241} = \frac{5543}{241} = 23$$

Calculamos el término independiente de la fila 3 que no se usará nuevamente:

$$ \frac{1205}{241} = 5$$

Matriz tras paso 1:

$$
\left(
\begin{array}{ccc|c}
1 & 7 & 0 & 23 \\
0 & 1 & 0 & 3 \\
0 & 0 & 1 & 5
\end{array}
\right)
$$

PASO 2: eliminar la columna 2 (usando la fila 2)

Operación \( F_1 \rightarrow F_1 – 7F_2\)

Columna 2:

$$7 – 7 = 0$$

Termino independiente:

$$23 – 7 \cdot 3 = 2$$

Matriz de identidad:

$$
\left(
\begin{array}{ccc|c}
1 & 0 & 0 & 2 \\
0 & 1 & 0 & 3 \\
0 & 0 & 1 & 5
\end{array}
\right)
$$

Solucion final

$$
\begin{cases}
p_1 = 2 \\
p_2 = 3 \\
p_3 = 5
\end{cases}
$$

Solución con Python

Para solucionar con python usamos numpy.linalg.solve, que aplica internamente eliminación de Gauss con pivotado, y es la forma más eficiente y segura de resolver sistemas lineales \(A \cdot x = b \) en Python.

import numpy as np

# Matriz de coeficientes
A = np.array([
    [3, 6, 2],
    [10, 3, 8],
    [1, 7, 5]
], dtype=float)

# Vector de resultados
b = np.array([34, 69, 48], dtype=float)

# Resolver el sistema A·x = b
sol = np.linalg.solve(A, b)

# Mostrar resultados
p1, p2, p3 = sol
print(f"p1 = {p1:.2f}, p2 = {p2:.2f}, p3 = {p3:.2f}")

import numpy as np

# Matriz de coeficientes
A = np.array([
    [3, 6, 2],
    [10, 3, 8],
    [1, 7, 5]
], dtype=float)

# Vector de resultados
b = np.array([34, 69, 48], dtype=float)

# Resolver el sistema A·x = b
sol = np.linalg.solve(A, b)

# Mostrar resultados
p1, p2, p3 = sol
print(f"p1 = {p1:.2f}, p2 = {p2:.2f}, p3 = {p3:.2f}")

Salida:

p1 = 2.00, p2 = 3.00, p3 = 5.00

p1 = 2.00, p2 = 3.00, p3 = 5.00

En el artículo anterior se trabajo los autovalores y autovectores, es común quedarse con la sensación de que son conceptos abstractos. Pero en realidad, están detrás de muchas de las herramientas más potentes del análisis de datos moderno.

Una de ellas es el Análisis de Componentes Principales (PCA), una técnica que permite comprimir información sin perder lo esencial.

En este artículo veremos cómo los eigenvectores sirven para reducir la dimensionalidad de los datos, y cómo este principio se aplica a algo tan visual como la compresión de imágenes de rostros humanos.

Cuando trabajamos con datos reales —imágenes, audio, sensores o registros de clientes— solemos tener miles de variables. Eso significa que el procesamiento se vuelve lento, costoso y muchas veces innecesario, porque buena parte de los datos son redundantes.

El PCA (Principal Component Analysis) se basa precisamente en encontrar las direcciones de mayor variabilidad dentro de los datos. Y esas direcciones no son otras que los autovectores de la matriz de covarianza del conjunto.

Visualizando el concepto con una imagen

Una imagen digital no es más que una matriz de números, donde cada valor representa la intensidad del color (por ejemplo, del blanco al negro si es en escala de grises).

Para este ejemplo usaremos el famoso dataset de rostros de celebridades incluido en scikit-learn.

from sklearn.datasets import fetch_lfw_people
import matplotlib.pyplot as plt

# Cargamos el dataset de caras
faces = fetch_lfw_people(min_faces_per_person=60)
image = faces.images[0]

plt.imshow(image, cmap='bone')
plt.title(f"Ejemplo de imagen: {faces.target_names[0]}")
plt.axis('off')
plt.show()

from sklearn.datasets import fetch_lfw_people
import matplotlib.pyplot as plt

# Cargamos el dataset de caras
faces = fetch_lfw_people(min_faces_per_person=60)
image = faces.images[0]

plt.imshow(image, cmap='bone')
plt.title(f"Ejemplo de imagen: {faces.target_names[0]}")
plt.axis('off')
plt.show()

Cada imagen tiene 62 filas × 47 columnas, es decir, 2.914 píxeles o variables.
PCA nos permitirá representar esta misma información con muchas menos variables.

Aplicando PCA paso a paso

PCA consiste básicamente en tres fases:

1. Calcular la matriz de covarianza del conjunto de datos.
2. Obtener sus autovectores y autovalores.
3. Proyectar los datos sobre las direcciones asociadas a los autovalores más grandes, que contienen la mayor parte de la varianza.

En código, podemos hacerlo así:

from sklearn.decomposition import PCA
import numpy as np

# Aplanamos las imágenes 2D a vectores 1D
X = faces.data

# Aplicamos PCA para conservar solo 15 componentes principales
pca = PCA(n_components=15)
X_pca = pca.fit_transform(X)

# Reconstruimos las imágenes desde los componentes principales
X_reconstructed = pca.inverse_transform(X_pca)

# Mostramos la imagen original y la reconstruida
fig, axes = plt.subplots(1, 2, figsize=(8, 4))
axes[0].imshow(X[0].reshape(62, 47), cmap='bone')
axes[0].set_title("Imagen original")
axes[0].axis('off')

axes[1].imshow(X_reconstructed[0].reshape(62, 47), cmap='bone')
axes[1].set_title("Reconstruida (15 componentes)")
axes[1].axis('off')

plt.show()

from sklearn.decomposition import PCA
import numpy as np

# Aplanamos las imágenes 2D a vectores 1D
X = faces.data

# Aplicamos PCA para conservar solo 15 componentes principales
pca = PCA(n_components=15)
X_pca = pca.fit_transform(X)

# Reconstruimos las imágenes desde los componentes principales
X_reconstructed = pca.inverse_transform(X_pca)

# Mostramos la imagen original y la reconstruida
fig, axes = plt.subplots(1, 2, figsize=(8, 4))
axes[0].imshow(X[0].reshape(62, 47), cmap='bone')
axes[0].set_title("Imagen original")
axes[0].axis('off')

axes[1].imshow(X_reconstructed[0].reshape(62, 47), cmap='bone')
axes[1].set_title("Reconstruida (15 componentes)")
axes[1].axis('off')

plt.show()

¿Qué estamos haciendo en realidad?

Cada componente principal es un autovector de la matriz de covarianza.
Cada uno representa una dirección en el espacio de datos donde la información cambia más.
Los autovalores indican cuánta “varianza” explica cada componente.

En este caso, al reconstruir la imagen con solo 15 componentes, vemos una versión algo borrosa, pero perfectamente reconocible. Hemos pasado de 2.914 variables a solo 15, manteniendo casi toda la información útil.

Si reducimos a 5 componentes, la imagen pierde detalle; si aumentamos a 50, se ve casi igual que la original. Todo depende del equilibrio que queramos entre tamaño y fidelidad.

Las “eigenfaces”

Una de las formas más visuales de entender PCA en imágenes es observar los autovectores directamente. En este caso se les conoce como eigenfaces, o “caras propias”.

Cada eigenface representa un patrón característico: sombras de ojos, contorno del rostro, luz lateral, expresión, etc.

Podemos verlos así:

fig, axes = plt.subplots(3, 5, figsize=(9, 6))
for i, ax in enumerate(axes.flat):
    ax.imshow(pca.components_[i].reshape(62, 47), cmap='bone')
    ax.set_title(f"Comp {i+1}")
    ax.axis('off')
plt.suptitle("Los 15 eigenfaces principales")
plt.show()

fig, axes = plt.subplots(3, 5, figsize=(9, 6))
for i, ax in enumerate(axes.flat):
    ax.imshow(pca.components_[i].reshape(62, 47), cmap='bone')
    ax.set_title(f"Comp {i+1}")
    ax.axis('off')
plt.suptitle("Los 15 eigenfaces principales")
plt.show()

Los eigenvectores son, en el fondo, una forma de entender la estructura interna de los datos.

Verás que, aunque una transformación lineal cambia la dirección de la mayoría de los vectores, existen algunos vectores especiales que no rotan, solo se estiran o encogen.
Esos vectores son los autovectores (eigenvector), y la cantidad por la que se estiran o encogen se llama autovalor (eigenvalues).

Intuición: vectores que no cambian de dirección

Imagina una matriz que representa una transformación lineal —por ejemplo, una matriz de “shear” (cizallamiento), que deforma un cuadrado en un paralelogramo.
En la mayoría de los casos, todos los vectores cambian de dirección al aplicar la transformación… excepto algunos muy particulares. Esos vectores especiales mantienen su dirección (aunque pueden cambiar su longitud). Por eso decimos que son autovectores.

Ejemplo de una transformación lineal:

import numpy as np

M = np.array([[2, 1],
              [1, 3]])

square = np.array([[0, 0, 1, 1, 0],
                   [0, 1, 1, 0, 0]])
transformed = M @ square

import numpy as np

M = np.array([[2, 1],
              [1, 3]])

square = np.array([[0, 0, 1, 1, 0],
                   [0, 1, 1, 0, 0]])
transformed = M @ square

fig, ax = plt.subplots(figsize=(8,8))
ax.plot(square[0], square[1], 'b--', label='Original')
ax.plot(transformed[0], transformed[1], 'r-', label=f'Shear con b={b}')

ax.set_xlim(-1, 3)
ax.set_ylim(-1, 3)
ax.axhline(0, color='black')
ax.axvline(0, color='black')
ax.set_aspect('equal')
ax.legend()
plt.show()

fig, ax = plt.subplots(figsize=(8,8))
ax.plot(square[0], square[1], 'b--', label='Original')
ax.plot(transformed[0], transformed[1], 'r-', label=f'Shear con b={b}')

ax.set_xlim(-1, 3)
ax.set_ylim(-1, 3)
ax.axhline(0, color='black')
ax.axvline(0, color='black')
ax.set_aspect('equal')
ax.legend()
plt.show()

Definición

Un vector \( \vec{v} \) es un autovector de una matriz \( M \) si, al aplicar la matriz transformadora sobre él, el resultado es el mismo vector escalado por un número \( \lambda \):

$$M \vec{v} = \lambda \vec{v}$$

Donde:

• \( M \) → es una matriz cuadrada \(n \times n\)
• \( \vec{v} \) → es un autovector
• \( \lambda \) → es el autovalor asociado

Este número \( \lambda \) indica cuánto se estira o encoge el vector cuando la matriz actúa sobre él.

Interpretación geométrica

• Si \( \lambda > 1 \): el vector se alarga.
• Si \( 0 < \lambda < 1 \): el vector se encoge.
• Si \( \lambda < 0 \): el vector cambia de sentido (se invierte).
• Si \( \lambda = 1 \): el vector queda igual.

Calculando los eigenvectors y eigenvalues

Continuamos con el ejemplo inicial:

import numpy as np

# Calcular eigenvalores y eigenvectores
w, V = np.linalg.eig(M)

print("\nEigenvalores:\n", w)
print("\nEigenvectores (columnas):\n", V)

import numpy as np

# Calcular eigenvalores y eigenvectores
w, V = np.linalg.eig(M)

print("\nEigenvalores:\n", w)
print("\nEigenvectores (columnas):\n", V)

Salida:

Eigenvalores:
 [1.38196601 3.61803399]

Eigenvectores (columnas):
 [[-0.85065081 -0.52573111]
 [ 0.52573111 -0.85065081]]

Eigenvalores:
 [1.38196601 3.61803399]

Eigenvectores (columnas):
 [[-0.85065081 -0.52573111]
 [ 0.52573111 -0.85065081]]

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(8,8))

# Cuadrado original (azul) y transformado (rojo)
ax.plot(square[0], square[1], 'b--', label='Original (cuadrado unidad)')
ax.plot(transformed[0], transformed[1], 'r-', label='Transformado M·S')

# Ejes
ax.axhline(0, color='black', linewidth=1)
ax.axvline(0, color='black', linewidth=1)

# Eigenvectores
for i in range(len(w)):
    v = V[:, i]            # vector propio
    Mv = M @ v             # su transformación
    λ = w[i]

    # Dibuja el eigenvector (azul)
    ax.quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1,
              color='blue', width=0.007, label=fr'$v_{i+1}$')

    # Dibuja el vector transformado (rojo)
    ax.quiver(0, 0, Mv[0], Mv[1], angles='xy', scale_units='xy', scale=1,
              color='red', width=0.007, label=fr'$M v_{i+1} = \lambda_{i+1} v_{i+1}$')

    # Muestra texto con el eigenvalor
    ax.text(Mv[0]*1.1, Mv[1]*1.1, fr'$\lambda_{i+1}={λ:.2f}$', color='red', fontsize=10)

ax.set_xlim(-4, 4)
ax.set_ylim(-4, 4)
ax.set_aspect('equal', adjustable='box')
ax.legend(loc='upper left', facecolor='none', edgecolor='none')
ax.set_title("Transformación lineal y Eigenvectores", fontsize=14)
ax.set_xlabel("x")
ax.set_ylabel("y")
plt.grid(True)
plt.show()

import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(8,8))

# Cuadrado original (azul) y transformado (rojo)
ax.plot(square[0], square[1], 'b--', label='Original (cuadrado unidad)')
ax.plot(transformed[0], transformed[1], 'r-', label='Transformado M·S')

# Ejes
ax.axhline(0, color='black', linewidth=1)
ax.axvline(0, color='black', linewidth=1)

# Eigenvectores
for i in range(len(w)):
    v = V[:, i]            # vector propio
    Mv = M @ v             # su transformación
    λ = w[i]

    # Dibuja el eigenvector (azul)
    ax.quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1,
              color='blue', width=0.007, label=fr'$v_{i+1}$')

    # Dibuja el vector transformado (rojo)
    ax.quiver(0, 0, Mv[0], Mv[1], angles='xy', scale_units='xy', scale=1,
              color='red', width=0.007, label=fr'$M v_{i+1} = \lambda_{i+1} v_{i+1}$')

    # Muestra texto con el eigenvalor
    ax.text(Mv[0]*1.1, Mv[1]*1.1, fr'$\lambda_{i+1}={λ:.2f}$', color='red', fontsize=10)

ax.set_xlim(-4, 4)
ax.set_ylim(-4, 4)
ax.set_aspect('equal', adjustable='box')
ax.legend(loc='upper left', facecolor='none', edgecolor='none')
ax.set_title("Transformación lineal y Eigenvectores", fontsize=14)
ax.set_xlabel("x")
ax.set_ylabel("y")
plt.grid(True)
plt.show()

Matrices simétricas

Cuando una matriz es simétrica (es decir, \( M = M^T \)), se cumple algo muy útil:

• Todos sus autovectores son perpendiculares entre sí.
• Sus autovalores son reales.

Por ejemplo:

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

autovalores, autovectores = np.linalg.eig(A)
print("Autovalores:", autovalores)
print("Autovectores:\n", autovectores)

print("Producto punto entre los autovectores:", np.dot(autovectores[:,0], autovectores[:,1]))

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

autovalores, autovectores = np.linalg.eig(A)
print("Autovalores:", autovalores)
print("Autovectores:\n", autovectores)

print("Producto punto entre los autovectores:", np.dot(autovectores[:,0], autovectores[:,1]))

La salida mostrará que el producto punto es 0, confirmando que los autovectores son ortogonales.

Autovalores: [5. 3.]
Autovectores:
 [[ 0.70710678 -0.70710678]
 [ 0.70710678  0.70710678]]
Producto punto entre los autovectores: 0.0

Autovalores: [5. 3.]
Autovectores:
 [[ 0.70710678 -0.70710678]
 [ 0.70710678  0.70710678]]
Producto punto entre los autovectores: 0.0

Aplicaciones en ciencia de datos

Los eigenvectores y eigenvalores son fundamentales en data science:

Análisis de Componentes Principales (PCA)

• Qué hace: Reduce dimensiones de un dataset encontrando los eigenvectores de la matriz de covarianza.
• Ejemplo: Dataset Iris (150×4) → eigenvectores indican las direcciones de mayor variación (ej: longitud vs ancho de pétalo).

Redes Neuronales

• Eigenvectores optimizan transformaciones en capas de redes profundas.
• Ejemplo: Ajustar pesos para maximizar patrones.

Procesamiento de Imágenes

• Eigenvectores en eigenfaces identifican características faciales clave.
• Ejemplo: Reconocimiento facial en apps de seguridad.

Sistemas Dinámicos

• Modelan cómo cambian datos con el tiempo (ej: predicciones financieras).
• Eigenvalores determinan la estabilidad de los sistemas.

Historia real: En 2024, Spotify usó eigenvectores en su sistema de recomendaciones para identificar patrones en gustos musicales, mejorando la precisión en un 10%.

Cómo encontrar los Eigenvalues y Eigenvectors

Para cualquier matriz \(M\):

1. Primero encontramos todos los eigenvalores λ.
2. Luego, usando esos eigenvalores, encontramos los eigenvectores correspondientes.

La ecuación base \(M \vec{v} = \lambda \cdot \vec{v}\) será la clave de todo.

Pero para trabajar con ella algebraicamente, vamos a transformarla un poco.

La matriz identidad

Necesitamos la matriz especial llamada la matriz identidad, que se denota por \(I\). La matriz identidad es una matriz cuadrada con unos en la diagonal principal (de arriba a la izquierda hasta abajo a la derecha) y ceros en todas las demás posiciones. Ya la vimos como ejemplo anteriormente en el articulo de las matrices.

Por ejemplo, la matriz identidad de tamaño 3×3 es:

$$I = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{bmatrix}$$

Y se llama “identidad” porque, al multiplicarla por cualquier matriz o vector, el resultado es exactamente el mismo.

Podemos decir que: \(I \cdot M = M\) y tambien que: \(I \cdot v = v\)

Manipulamos la ecuación para llegar al sistema característico

Volvamos a nuestra ecuación:

$$M \vec{v} = \lambda \cdot \vec{v}$$

Podemos escribir el lado derecho como \(\lambda I \cdot v\), ya que \(I \cdot v.\).

Entonces la ecuación queda así:

$$M \vec{v} = \lambda I \cdot \vec{v}$$

Restamos el término del lado derecho en ambos lados:

$$M \cdot \vec{v} \ – \lambda I \cdot \vec{v} = 0 $$

Sacamos vvv como factor común (como si fuera un número):

$$(M \ – \lambda I) \cdot \vec{v} = 0 $$

Y esta ecuación es fundamental: se conoce como la ecuación característica.

La condición de existencia de eigenvectores

Esta ecuación tiene dos tipos de soluciones posibles:

1. La trivial, cuando \(v=0\).
   Pero ese vector no nos dice nada (no tiene dirección ni longitud), así que lo descartamos.
2. La no trivial, cuando \(v≠0\).
   Para que exista esta solución, debe cumplirse una condición especial.

Recuerda una propiedad del álgebra lineal:

Una ecuación de la forma \(A \cdot v=0\) solo tiene una solución no trivial \(v≠0\) si la matriz A es singular, es decir, su determinante es igual a cero.

Aplicando esto a nuestra ecuación \((M \ – \lambda I) \cdot \vec{v} = 0 \), la condición será: \(det(M \ – \lambda I) \cdot \vec{v} = 0 \)

Esta ecuación nos permitirá encontrar los valores de \( \lambda \), los eigenvalores.

Interpretación geométrica: el área que se hace cero

Detrás de todo esto hay una idea visual muy poderosa.

Imagina que tienes una matriz \(M\) que transforma puntos del plano \(XY\). Puedes representarla como una transformación del cuadrado unitario (un cuadrado de lado 1 anclado en el origen).

Cuando multiplicas \(M\) por las coordenadas de los vértices de ese cuadrado, obtienes un nuevo cuadrilátero. En general, este nuevo cuadrilátero es un paralelogramo.

• Si \(M\) solo escala el cuadrado, obtienes un rectángulo.
• Si además deforma el cuadrado (por ejemplo, en un cizallamiento), obtienes un paralelogramo inclinado.

El área de ese paralelogramo es una medida de cuánto “estira” o “encoge” la transformación de \(M\).
Y el determinante de la matriz está directamente relacionado con esa área.

Cuando el determinante es cero, significa que la transformación ha colapsado el plano en una línea o un punto, es decir, ha perdido una dimensión. Eso ocurre exactamente cuando estamos en un eigenvalor, porque en ese caso el espacio queda “aplastado” en una dirección particular: la del eigenvector.

Ejemplo visual con una matriz 2×2

Imaginemos una matriz genérica \(M\) de 2×2:

$$M = \begin{bmatrix} a & b \\ c & d \end{bmatrix}$$

Y tomemos el cuadrado unitario cuyos vértices son (0,0), (1,0), (1,1) y (0,1).

Cuando aplicamos \(M\) sobre esos puntos, el cuadrado se transforma en un paralelogramo cuyos vértices vienen dados por los productos matriciales:

$$M \cdot S$$

donde \(S\) contiene las coordenadas de los vértices del cuadrado.
El área de ese nuevo paralelogramo se puede calcular directamente como:

$$\text{Área} = ad – bc$$

que es precisamente el determinante de \(M\).

Así que cuando el determinante \(ad−bc=0\), el paralelogramo “se aplasta” y pierde área. Geométricamente, eso es lo que ocurre cuando hay un eigenvalor: la transformación ya no conserva el área y “colapsa” el espacio en una dirección.

Cálculo con Python: encontrar los eigenvalores

Ejemplo con matriz 2×2.

$$M = \begin{bmatrix} 2 & 1 \\ 1 & 2 \end{bmatrix}$$

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

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

Calculamos eigenvalores y eigenvectores

eigenvalores, eigenvectores = np.linalg.eig(M)

print("Matriz M:")
print(M)

print("\nEigenvalores:")
print(eigenvalores)

print("\nEigenvectores (por columnas):")
print(eigenvectores)

eigenvalores, eigenvectores = np.linalg.eig(M)

print("Matriz M:")
print(M)

print("\nEigenvalores:")
print(eigenvalores)

print("\nEigenvectores (por columnas):")
print(eigenvectores)

Eigenvalores:
[1.38196601 3.61803399]

Eigenvectores (por columnas):
[[-0.85065081 -0.52573111]
 [ 0.52573111 -0.85065081]]

Eigenvalores:
[1.38196601 3.61803399]

Eigenvectores (por columnas):
[[-0.85065081 -0.52573111]
 [ 0.52573111 -0.85065081]]

Ejemplo con matriz 3×3.

M3 = np.array([
    [4, -2, 1],
    [0, 3, -1],
    [0, 0, 2]
])

eigenvalores3, eigenvectores3 = np.linalg.eig(M3)

print("Matriz M3:")
print(M3)

print("\nEigenvalores:")
print(eigenvalores3)

print("\nEigenvectores (por columnas):")
print(eigenvectores3)

M3 = np.array([
    [4, -2, 1],
    [0, 3, -1],
    [0, 0, 2]
])

eigenvalores3, eigenvectores3 = np.linalg.eig(M3)

print("Matriz M3:")
print(M3)

print("\nEigenvalores:")
print(eigenvalores3)

print("\nEigenvectores (por columnas):")
print(eigenvectores3)

Matriz M3:
[[ 4 -2  1]
 [ 0  3 -1]
 [ 0  0  2]]

Eigenvalores:
[4. 3. 2.]

Eigenvectores (por columnas):
[[1.         0.89442719 0.33333333]
 [0.         0.4472136  0.66666667]
 [0.         0.         0.66666667]]

Matriz M3:
[[ 4 -2  1]
 [ 0  3 -1]
 [ 0  0  2]]

Eigenvalores:
[4. 3. 2.]

Eigenvectores (por columnas):
[[1.         0.89442719 0.33333333]
 [0.         0.4472136  0.66666667]
 [0.         0.         0.66666667]]

¿Qué es una matriz?

Si los vectores son puntos en un mapa, las matrices son el mapa completo: una matriz es una cuadrícula de números organizada en filas y columnas. Puedes pensarla como un conjunto de vectores fila o vectores columna, dependiendo del caso.

Matemáticamente, se escribe como un conjunto rectangular o cuadrado de números. Cada número dentro de la matriz se llama elemento, y se identifica por su posición: \(a_{ij}\) es el elemento que está en la fila i y la columna j.

$$ A = \begin{bmatrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33} \end{bmatrix} $$

Aquí la matriz \(A\) tiene 3 filas y 3 columnas, por lo tanto, su dimensión es \(3 \times 3\).

• Filas: 3 (cada una es un vector)
• Columnas: 3 (cada una es un vector)
• Dimensión: \(3×3\) (filas x columnas)

Dimensiones

Scalar

$$a = 1$$

1D: vector columna o vector fila, según la orientación

• 2D Matriz

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

• 3D Tensor

$$T_{ijk} = \begin{bmatrix}[1 & 2] & [3 & 4] \\ [5 & 6] & [7 & 8]\end{bmatrix}$$

Tipos de matrices

Matriz fila y matriz columna vistas anteriormente en la dimension 1D

Matriz cuadrada: tiene el mismo número de filas y columnas \( (n \times n) \).

$$ A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} $$

• Diagonar mayor: a = [1 , 5 , 9]
• Diagonal menor: a = [3 , 5 , 7]

Matriz de identidad o unidad: tiene 1 en la diagonal principal y 0 en el resto.

$$A = \begin{bmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix}$$

Matriz Escalar: Todos los elementos de la diagonal son iguales.

$$A = \begin{bmatrix}3 & 0 & 0 \\ 0 & 3 & 0 \\ 0 & 0 & 3 \end{bmatrix}$$

Matriz triangular superior y triangular inferior.

Matriz Diagonal: los elementos que no están en la diagonal principal son ceros.

$$A = \begin{bmatrix}1 & 0 & 0 \\ 0 & 5 & 0 \\ 0 & 0 & 9 \end{bmatrix}$$

Matriz nula: todos los elementos son 0.

$$A = \begin{bmatrix}0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{bmatrix}$$

La matriz identidad, por ejemplo, es clave porque actúa como el “1” de la multiplicación matricial:

$$I = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} \quad \Rightarrow \quad A \cdot I = A$$

Matriz traspuesta: Se obtiene intercambiando filas por columnas:

Matriz simétrica: cuando es igual a su traspuesta.

Matrices como datos

En ciencia de datos, todo lo que analizamos puede representarse con matrices:

• Un dataset es una matriz donde cada fila es una observación y cada columna una variable.
• Una imagen es una matriz de píxeles, y si es en color, es una matriz 3D , también llamado Tensor.
• Una serie temporal puede representarse como una matriz con las variables en columnas y el tiempo en filas.

Por ejemplo, una imagen en blanco y negro de 3×3 se puede representar así:

$$ I =\begin{bmatrix}0 & 255 & 0 \\ 255 & 0 & 255 \\ 0 & 255 & 0\end{bmatrix}$$

donde cada número representa la intensidad del color.

Matrices como funciones

También llamada Matrices Transformadoras, son matrices que actuan como una función que transforma datos.

Una transformación lineal es una función que toma vectores como entrada y devuelve otros vectores como salida. Las transformaciones lineales pueden:

• Estirar o encoger figuras (cambio de escala)
• Girarlas (rotación)
• Reflejarlas (simetría)
• Aplanarlas (proyección)
• Combinarlas (rotar + escalar, por ejemplo)

Pero no pueden doblar, curvar, ni mover los puntos de forma no proporcional (eso sería una transformación no lineal).

Por ejemplo, en geometría o visión por computador, una matriz de rotación de un ángulo \((\theta)\) es:

$$R(\theta) = \begin{bmatrix}\cos \theta & -\sin \theta \\ sin \theta & \cos \theta \end{bmatrix}$$

Aplicar esta matriz a un vector rota el punto alrededor del origen.

Operaciones con Matrices

Suma y resta de matrices

Dos matrices se pueden sumar o restar solo si tienen el mismo tamaño. Se suman los elementos correspondientes en cada matriz:

$$ A + B = \begin{bmatrix} a_{11}​+b_{11} & a_{12}​+b_{12}​ \\ ​a_{22}​+b_{22}​​ & a_{21}+b_{21} \end{bmatrix}$$

Multiplicación por un scalar

Cada elemento de la matriz se multiplica por el número (escalar):

$$ 2A = \begin{bmatrix} 2a_{11} & 2a_{12}​ \\ ​2a_{22}​​​ & 2a_{21​​​} \end{bmatrix}$$

Producto de matrices

Para poder multiplicar dos matrices es necesario que el número de columnas de la primera matriz sea igual al número de filas de la segunda. Para realizar la multiplicación se multiplican los elementos de cada fila de A por cada elemento de las columnas de B y se suman los resultados.

$$(A \times B)_{ij} = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}$$

$$ = \begin{bmatrix} 1 \cdot 5 + 2 \cdot 7 & 1 \cdot 6 + 2 \cdot 8 \\ 3 \cdot 5 + 4 \cdot 7 & 3 \cdot 6 + 4 \cdot 8\end{bmatrix} $$

$$ = \begin{bmatrix} 19 & 22 \\ 43 & 50 \end{bmatrix} $$

Operaciones de Matrices con Python

• Crear matrices con funciones convenientes, Numpy ofrece varias funciones para crear matrices comunes rapidamente:

A = np.ones((3, 4))   # Matriz 3x4 llena de unos
B = np.zeros((3, 3))  # Matriz 3x3 llena de ceros
C = np.ones((2, 2)) * 4  # Matriz 2x2 llena de cuatros

print("A:\n", A)
print("B:\n", B)
print("C:\n", C)

A = np.ones((3, 4))   # Matriz 3x4 llena de unos
B = np.zeros((3, 3))  # Matriz 3x3 llena de ceros
C = np.ones((2, 2)) * 4  # Matriz 2x2 llena de cuatros

print("A:\n", A)
print("B:\n", B)
print("C:\n", C)

A:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
B:
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
C:
 [[4. 4.]
 [4. 4.]]

A:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
B:
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
C:
 [[4. 4.]
 [4. 4.]]

• Propiedad .shape: conocer las dimensiones de la matriz

print(A.shape)

print(A.shape)

(3, 4)

(3, 4)

• Indexación: acceder a elementos, fila y columnas

M = np.array([[1, 2, 3],
              [4, 5, 6]
              [7, 8, 9]])
              
valor = M[4, 5]  # valor en la fila 5, columna 6 (Python indexa desde 0)
fila = M[1, :]  # acceder a una fila completa
columna = M[:, 2]  # acceder a una columna completa

print(valor)
print(fila)
print(columna)

M = np.array([[1, 2, 3],
              [4, 5, 6]
              [7, 8, 9]])
              
valor = M[4, 5]  # valor en la fila 5, columna 6 (Python indexa desde 0)
fila = M[1, :]  # acceder a una fila completa
columna = M[:, 2]  # acceder a una columna completa

print(valor)
print(fila)
print(columna)

6
[4 5 6]
[3 6 9]

6
[4 5 6]
[3 6 9]

• Suma y resta de matrices

C = A + B
D = B - A

C = A + B
D = B - A

• Multiplicación por escalar

E = 3 * A

E = 3 * A

• Producto de matrices

C = A @ B
# tambien se puede usar:
np.dot(A, B)

C = A @ B
# tambien se puede usar:
np.dot(A, B)

• Transpuesta de una matriz

print("A^T =\n", A.T)

print("A^T =\n", A.T)

• Matriz identidad

I = np.eye(2)
print("Matriz identidad:\n", I)

print("A @ I =\n", A @ I)

I = np.eye(2)
print("Matriz identidad:\n", I)

print("A @ I =\n", A @ I)

• Determinante y matriz inversa

det_A = np.linalg.det(A)
inv_A = np.linalg.inv(A)

det_A = np.linalg.det(A)
inv_A = np.linalg.inv(A)

6. En resumen

• Las matrices son la base del álgebra lineal y de los modelos de datos.
• En Machine Learning, cada conjunto de entrenamiento es una gran matriz.
• En visión por computador, las imágenes son matrices.
• En análisis estadístico, las transformaciones de los datos se hacen con multiplicaciones matriciales.

Por eso, entender cómo funcionan es esencial: todo modelo, por complejo que parezca, se reduce a operaciones con vectores y matrices.

Imagina que los datos son como puntos en un mapa. Un vector es la flecha que describe dónde está ese punto y cómo llegar a él. En data science, los vectores son la forma más básica y poderosa de representar datos, desde características de un cliente hasta píxeles en una imagen.

El vector es el elemento fundamental y raíz de toda el algebra lineal.

Los vectores no son solo un concepto matemático para escribir ecuaciones de forma concisa.
También son herramientas fundamentales para codificar información compleja, desde posiciones y velocidades hasta fuerzas y movimientos en varias dimensiones.

¿Qué es un vector?

Más allá de ser una lista ordenada de números, un vector puede pensarse como: cualquier cosa que tenga una dirección y una magnitud.

Es una lista ordenada de números que describe una posición o característica en un espacio. En data science, cada vector representa un punto de datos y cada fila de tu dataset es un vector.

Esta definición es la que usan los físicos. Por ejemplo:

• Dirección: hacia dónde apunta el vector.
• Magnitud: qué tan grande es, también llamada norma del vector.

Ejemplos

Supongamos que describes a una persona por su edad y salario:

• Vector: \([25, 50000]\)
  • 25: Edad (en años)
  • 50000: Salario (en euros)

Visualmente:

• Un vector es una flecha en un plano:
  • Origen: \((0,0)\)
  • Punta: \((25, 50000)\)
• En 2D, se ve como una línea desde el origen al punto.

Dimensiones

• 2D: \([x, y]\) (ej: edad, salario)
• 3D: \([x, y, z]\) (ej: edad, salario, experiencia)
• n-D: \([x₁, x₂, …, xₙ]\) (datasets con muchas columnas)

De la Ecuación al Movimiento

Imaginemos una pelota lanzada desde el origen que en términos de vectores seria la posición \((0,0)\) en un espacio bidimensional. La posición de la pelota en cada instante se puede codificar como un vector \( \mathbf{p} = (p_1, p_2) \), donde:

• \(p_1 = 5\) representa la posición horizontal \(x\)
• \(p_2 = 4\) representa la posición vertical \(y\).

Así, en lugar de seguir las coordenadas de los ejes por separado, podemos usar un solo vector para describir la posición de la pelota.

$$ \vec{p} = \begin{bmatrix}5\\4\end{bmatrix}$$

Si representamos \(\vec{p}\)​ en un plano cartesiano, se vería como una flecha que parte del origen (0,0) y termina en (5,4). La flecha tiene una dirección (hacia dónde apunta) y una longitud, que nos dice qué tan lejos está el punto final del origen. Para graficar podemos utilizar ax.arrow() en Matplotlib.

import matplotlib.pyplot as plt

# Crear figura y ejes
fig, ax = plt.subplots(figsize=(8, 8))

# Dibujar el vector desde (0,0) hasta (5,4)
ax.arrow(0, 0, 5, 4, head_width=0.3, head_length=0.4, fc='blue', ec='blue', linewidth=2)

# Marcar el punto final del vector
ax.plot(5, 4, 'o', markersize=6, color='blue')
ax.plot(0, 0, 'o', markersize=6, color='blue')
ax.text(5.6, 4, r"$\vec{v} = [5,\, 4]$", fontsize=14, color='blue')

# Ejes centrados
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('zero')

# Quitar bordes superior y derecho
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)

# Color y grosor de los ejes
for spine in ['left', 'bottom']:
    ax.spines[spine].set_color('gray')
    ax.spines[spine].set_linewidth(1)

# Límites y cuadrícula
ax.set_xlim(-6, 8)
ax.set_ylim(-6, 8)
ax.grid(False)

# Tamaño de los números de los ejes
ax.tick_params(axis='both', which='major', labelsize=10)

# Etiquetas y título
ax.set_xlabel(r"$x$", fontsize=14, loc="right")
ax.set_ylabel(r"$y$", fontsize=14, loc="top", rotation=0)
ax.set_title("Vector", pad=20)

# Guardar y mostrar
plt.savefig("vector.png", transparent=True, dpi=300)
plt.show()

import matplotlib.pyplot as plt

# Crear figura y ejes
fig, ax = plt.subplots(figsize=(8, 8))

# Dibujar el vector desde (0,0) hasta (5,4)
ax.arrow(0, 0, 5, 4, head_width=0.3, head_length=0.4, fc='blue', ec='blue', linewidth=2)

# Marcar el punto final del vector
ax.plot(5, 4, 'o', markersize=6, color='blue')
ax.plot(0, 0, 'o', markersize=6, color='blue')
ax.text(5.6, 4, r"$\vec{v} = [5,\, 4]$", fontsize=14, color='blue')

# Ejes centrados
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('zero')

# Quitar bordes superior y derecho
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)

# Color y grosor de los ejes
for spine in ['left', 'bottom']:
    ax.spines[spine].set_color('gray')
    ax.spines[spine].set_linewidth(1)

# Límites y cuadrícula
ax.set_xlim(-6, 8)
ax.set_ylim(-6, 8)
ax.grid(False)

# Tamaño de los números de los ejes
ax.tick_params(axis='both', which='major', labelsize=10)

# Etiquetas y título
ax.set_xlabel(r"$x$", fontsize=14, loc="right")
ax.set_ylabel(r"$y$", fontsize=14, loc="top", rotation=0)
ax.set_title("Vector", pad=20)

# Guardar y mostrar
plt.savefig("vector.png", transparent=True, dpi=300)
plt.show()

La norma (longitud del vector): cuánto ha viajado la pelota

Esa longitud, también llamada norma, nos dice qué tan grande es el vector.
Se denota con dos barras verticales, así: \( ||\mathbf{p}|| \) Para saber qué tan lejos está la pelota desde el origen, usamos la norma del vector:

$$||\mathbf{p}|| = \sqrt{p_1^2 + p_2^2}$$

Esta ecuación se deriva directamente del teorema de Pitágoras: la hipotenusa de un triángulo rectángulo es la raíz cuadrada de la suma de los cuadrados de sus catetos. Por ejemplo, si \(p_1 = 5\) y \(p_2 = 4\), la norma es:

$$||\mathbf{p}|| = \sqrt{5^2 + 4^2} \approx 6.40$$

La norma siempre da como resultado un número positivo: la distancia desde el origen hasta el punto final del vector.

Vectores en dimensiones superiores

Si la pelota se moviera en un espacio tridimensional, solo agregamos un componente más:

$$\mathbf{p} = (p_1, p_2, p_3), \quad $$

$$||\mathbf{p}|| = \sqrt{p_1^2 + p_2^2 + p_3^2}$$

Y si tuviéramos un vector en \(N\) dimensiones, simplemente añadimos cada componente al cálculo de la norma:

$$||\mathbf{p}|| = \sqrt{p_1^2 + p_2^2 + \dots + p_N^2}$$

Esto hace que los vectores sean muy poderosos para manejar información compleja de manera compacta.

Aplicaciones de los vectores en física

Los vectores nos permiten representar de manera eficiente:

• Posición: dónde se encuentra un objeto.
• Velocidad: dirección y rapidez del movimiento.
• Fuerza: hacia dónde actúa y cuán intensa es.

Además, con operaciones como suma, resta, multiplicación por escalar o producto punto, podemos combinar vectores y calcular efectos resultantes de manera simple.

Por ejemplo, en nuestra pelota de béisbol, un vector nos permite:

• Conocer simultáneamente su posición en \(x\) y \( y\) ,
• Medir su distancia desde el punto de lanzamiento con la norma,
• Y si quisiéramos incluir velocidad o aceleración, usar vectores de mayor dimensión para mantener todo compacto y manejable.

Dos propiedades clave de un vector

1. Dirección: hacia dónde apunta.
2. Magnitud: cuán grande es, calculable con la norma.

En cualquier número de dimensiones, esta regla sigue siendo válida, lo que convierte a los vectores en herramientas universales para describir información física y multidimensional.

Operaciones con Vectores

Los vectores son poderosos porque puedes operarlos para descubrir patrones. Aquí las operaciones más importantes:

Suma de Vectores

si tenemos dos vectores de la misma dimensión:

$$ \vec{u} = \begin{bmatrix}u_1\\u_2\\u_3\end{bmatrix}, \vec{v} = \begin{bmatrix}v_1\\v_2\\v_3\end{bmatrix}$$

La suma es simplemente sumar cada componente correspondiente:

$$ \vec{u} + \vec{v}= \begin{bmatrix}u_1+v_1\\u_2+v_2\\u_3+v_3\end{bmatrix}$$

Esto es útil porque cuando sumamos vectores estamos combinando información de manera ordenada, igual que antes combinábamos cantidades de manzanas, naranjas y pan. La suma de vectores es la primera forma de “agrupar información” en un vector.

Multiplicación por escalar

Si tenemos un número \(k\) y un vector \(\vec{v}\), multiplicamos cada componente por ese número:

$$ k \cdot \vec{v}= k \cdot \begin{bmatrix}v_1\\v_2\\v_3\end{bmatrix} = \begin{bmatrix}kv_1\\kv_2\\kv_3\end{bmatrix}$$

Esto sirve para escalar vectores, como cuando queremos “duplicar” o “reducir” una cantidad.

Producto Escalar (Dot Product)

Dot Product: Mide la similitud entre dos vectores.

El producto escalar es una operación entre dos vectores que produce un número, a diferencia de la suma o resta de vectores, que produce otro vector.

Si tenemos dos vectores de la misma dimensión:

$$ \vec{a} = \begin{bmatrix}a_1\\a_2\\.\\.\\.\\a_n\end{bmatrix}, \vec{b} = \begin{bmatrix}b_1\\b_2\\.\\.\\.\\b_n\end{bmatrix}$$

el producto punto se define como:

$$ \vec{a} \cdot \vec{b} = a_1b_1 + a_2b_2 + . . . + a_nb_n$$

O, lo que es lo mismo:

$$ \vec{a} \cdot \vec{b} = \sum ^{n} _ {i=1} a_ib_i$$

Cada componente se multiplica componente por componente, y luego se suman los resultados.

Ejemplo:

Supongamos que tienes un presupuesto de $30 y quieres comprar: manzanas, naranjas y peras.

Definimos:

• Vector de cantidades compradas

$$ \vec{g} = \begin{bmatrix}g_1\\g_2\\g_3\end{bmatrix} = \begin{bmatrix}4\\3\\2\end{bmatrix} $$

• Vector de precios de productos:

$$ \vec{c} = \begin{bmatrix}c_1\\c_2\\c_3\end{bmatrix} = \begin{bmatrix}2\\3\\5\end{bmatrix}$$

Entonces, el total gastado se puede escribir como:

$$ Total= \vec{c} \cdot \vec{g} $$

$$ T= c_1g_1 + c_2g_2 + c_3g_3 $$

$$ T = 2⋅4+3⋅3+5⋅2$$

$$ T =8+9+10=27$$

Interpretación geométrica

Geométricamente, el producto punto mide cuánto se parecen o se alinean dos vectores en dirección:

$$\vec{a} \cdot \vec{b} = |\vec{a}|\: |\vec{b}| \: cos⁡(θ)$$

• Si \(θ=0°\): los vectores están en la misma dirección → producto punto positivo y máximo.
• Si \(θ=90°\): son perpendiculares → producto punto = 0.
• Si \(θ>90°\): apuntan en direcciones opuestas → producto punto negativo.

Esto significa que el producto punto mide cuánto “apuntan en la misma dirección” dos vectores.

Ecuaciones como producto escalar

Entiende la idea base

La expresión general:

$$y=a_1​x_1​+a_2​x_2​+⋯+a_n​x_n​$$

Es el punto de partida que lleva directamente a la forma matricial de los sistemas lineales.

Partimos del sistema:

$$\begin{cases} 2x + 3y = 30 \\ x + y = 12 \end{cases}$$

Es el resultado de un producto punto entre dos vectores.

$$\begin{bmatrix} 2 & 3 \\ 1 & 1 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} 30 \\ 12 \end{bmatrix}$$

Significado de las partes:

La forma vectorial compacta del sistema matricial se expresa como:

$$A\vec{x} = \vec{b}$$

Donde:

• \(A\) –> es la matriz de coeficientes
• \(\vec{x}\) –> es el vector de incógnitas
• \(\vec{b}\) –> es el vector de términos independientes

Por tanto:

$$A = \begin {bmatrix} 2 & 3 \\ 1 & 1 \end{bmatrix}, \vec{x} = \begin{bmatrix} x \\ y \end{bmatrix}, \vec{b} = \begin{bmatrix} 30 \\ 12 \end{bmatrix}$$

Antes de hablar de matrices, hay una idea fundamental. Una ecuación lineal es un producto escalar.

ones

En resumen:

• Una ecuación lineal = producto escalar
• Un sistema = varios productos escalares
• Una matriz = colección de vectores fila
• Multiplicar matriz por vector = aplicar todos los productos escalares

Usos del producto escalar en data science

• Similitud de vectores (cosine similarity): En NLP, sistemas de recomendación o embeddings de palabras. Cuanto mayor sea este valor, más similares son los vectores.
• Regresión lineal / Neuronas : Calcula la combinación lineal de las variables
• Similitud del coseno : Mide cuánto se parecen dos vectores
• PCA / Proyecciones : Proyecta un vector sobre una dirección
• Distancias : Base para métricas vectoriales
• Álgebra de matrices : Operación elemental en multiplicación de matrices

Operaciones de vectores con Python

Los vectores en Python se manejan con Numpy y se representan como listas:

v = np.array([2, 3])
w = np.array([1, -1])

v = np.array([2, 3])
w = np.array([1, -1])

Suma y resta de vectores

C = v + w
d = v - w
rint(f"{c}\n{d}")

C = v + w
d = v - w
rint(f"{c}\n{d}")

[3 2]
[1 4]

[3 2]
[1 4]

Multiplicación por escalar

F = 2 * v
print(F)

F = 2 * v
print(F)

[4 6]

[4 6]

Producto escalar

P = np.dot(v, w)
print(P)

P = np.dot(v, w)
print(P)

P = np.dot(v, w)
print(P)

P = np.dot(v, w)
print(P)

-1

-1

Norma del vector

M = np.linalg.norm(v)
print(M)

M = np.linalg.norm(v)
print(M)

3.605551275463989

3.605551275463989

Vector unitario

U = v / np.linalg.norm(v)
print(U)

U = v / np.linalg.norm(v)
print(U)

[0.5547002  0.83205029]

[0.5547002  0.83205029]

Ángulo entre vectores

cos_theta = np.dot(v, w) / (np.linalg.norm(v) * np.linalg.norm(w))
A = np.arccos(cos_theta)

print(A)

cos_theta = np.dot(v, w) / (np.linalg.norm(v) * np.linalg.norm(w))
A = np.arccos(cos_theta)

print(A)

1.7681918866447774

1.7681918866447774