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.