La forma escalonada por filas revela características de IA redundantes

Cuando un modelo tiene tres columnas de características, es tentador suponer que dispone de tres direcciones independientes de las que aprender. Sin embargo, una característica puede estar presente en los datos sin aportar información nueva. Si una columna es una combinación de las demás, el modelo puede ajustar las mismas predicciones con muchos vectores de parámetros diferentes.

La forma escalonada por filas hace visible esa estructura oculta. Al terminar esta lección podrás localizar pivotes, identificar variables libres, describir una solución general y usar una pequeña implementación en NumPy para diagnosticar características redundantes sin confundir una advertencia numérica con una conclusión matemática.

Resultado de aprendizaje: Encontrar pivotes, variables libres y una solución general.

La lección 23: La eliminación de Gauss conserva el conjunto de soluciones introdujo las operaciones legales por filas que mantienen sin cambios las soluciones de un sistema. La lección 18: Las matrices organizan reglas lineales presentó la matriz de coeficientes. El sitio oficial complementario de Mathematics for Machine Learning sitúa esta lección en la sección 2.3 del PDF actual del libro. Los números, el escenario de características, el código, la visualización y las evaluaciones de esta lección son originales.

Una escalera registra lo que las ecuaciones pueden determinar

Comienza con una matriz $Ainmathbb{R}^{m\times n}$ . Una matriz está en forma escalonada por filas cuando cumple tres reglas estructurales:

Cada fila no nula aparece por encima de todas las filas completamente nulas.
La primera entrada no nula de cada fila no nula, llamada pivote, aparece más a la derecha que el pivote de la fila anterior.
Todas las entradas situadas debajo de un pivote son cero.

Los pivotes forman una escalera de izquierda a derecha. Una columna pivote es una dirección que las filas restringen. Una columna sin pivote es una dirección libre: su valor puede variar mientras las ecuaciones determinan las demás variables a su alrededor.

La forma escalonada por filas no es lo mismo que la forma escalonada reducida por filas. La forma reducida también exige que cada pivote sea igual a $1$ y sea la única entrada no nula de su columna. Cualquiera de las dos formas puede revelar el rango y las variables libres; la forma reducida suele ser más cómoda para leer una respuesta parametrizada.

La visualización siguiente mantiene visibles los estados intermedios. La matriz final tiene dos pivotes, en las columnas $f_1$ y $f_2$ ; la columna $f_3$ no tiene pivote.

Registro estático de reducción por filas

Los pivotes forman una escalera

Cada estado mantiene visible la matriz completa. El pivote de la última fila no nula está más a la derecha que el de la fila superior, y la fila de ceros ha bajado hasta el final.

Paso 0Matriz de características originalInicio
Matriz de características original
Fila f₁ f₂ f₃
R1 1 2 3
R2 2 4 6
R3 1 1 2
Paso 1Anular la primera columna debajo del pivoteR₂ ← R₂ − 2R₁; R₃ ← R₃ − R₁
Anular la primera columna debajo del pivote
Fila f₁ f₂ f₃
R1 1 2 3
R2 0 0 0
R3 0 -1 -1
Paso 2Subir la fila no nulaR₂ ↔ R₃
Subir la fila no nula
Fila f₁ f₂ f₃
R1 1 2 3
R2 0 -1 -1
R3 0 0 0
Paso 3Normalizar el segundo pivoteR₂ ← −R₂
Normalizar el segundo pivote
Fila f₁ f₂ f₃
R1 1 2 3
R2 0 1 1
R3 0 0 0

Matriz de características original
Fila	f₁	f₂	f₃
R1	1	2	3
R2	2	4	6
R3	1	1	2

Anular la primera columna debajo del pivote
Fila	f₁	f₂	f₃
R1	1	2	3
R2	0	0	0
R3	0	-1	-1

Subir la fila no nula
Fila	f₁	f₂	f₃
R1	1	2	3
R2	0	-1	-1
R3	0	0	0

Normalizar el segundo pivote
Fila	f₁	f₂	f₃
R1	1	2	3
R2	0	1	1
R3	0	0	0

Las entradas resaltadas son los pivotes de la estructura final. La columna f₃ no tiene pivote, así que es la dirección libre que revela la característica redundante.

Las operaciones por filas exponen dos direcciones de características independientes y una columna redundante. Las entradas subrayadas marcan las posiciones de los pivotes finales.

Ejemplo resuelto: una columna de características redundante

Imagina una matriz de diseño pequeña cuyas columnas resumen tres señales extraídas para tres ejemplos:

$f_1$ : intensidad de coincidencia en la recuperación;
$f_2$ : intensidad de verificación; y
$f_3$ : una señal combinada que se registró por accidente como una característica separada.

La matriz es

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

Antes de reducirla, observa que la tercera columna es la suma de las dos primeras: $f_3=f_1+f_2$ . Es una intuición útil, pero la reducción por filas nos proporciona un procedimiento que también funciona cuando la relación no resulta evidente a simple vista.

Primero usa la entrada superior izquierda como pivote. Elimina las entradas que están debajo:

R_2\leftarrow R_2-2R_1, \qquad R_3\leftarrow R_3-R_1,

lo que produce

\begin{bmatrix} 1&2&3\\ 0&0&0\\ 0&-1&-1 \end{bmatrix}.

La segunda fila se vuelve cero temporalmente, pero el sistema no ha perdido información: la fila no nula que está debajo aún debe subir. Intercambia las filas y después multiplica la nueva segunda fila por $-1$ :

\begin{bmatrix} 1&2&3\\ 0&-1&-1\\ 0&0&0 \end{bmatrix} \quad\longrightarrow\quad \boxed{ \begin{bmatrix} 1&2&3\\ 0&1&1\\ 0&0&0 \end{bmatrix}}.

Los pivotes están en las columnas 1 y 2. La columna 3 no tiene pivote, así que es la columna libre. La matriz tiene rango 2 en lugar de 3: los datos contienen tres características con nombre, pero solo dos direcciones independientes.

Las variables libres describen una familia, no un fracaso

Para ver qué significa la ausencia de un pivote, añade un lado derecho compatible con las mismas relaciones entre filas:

\begin{bmatrix} 1&2&3&\mid&4\\ 2&4&6&\mid&8\\ 1&1&2&\mid&3 \end{bmatrix}.

Las mismas operaciones producen

\begin{bmatrix} 1&0&1&\mid&2\\ 0&1&1&\mid&1\\ 0&0&0&\mid&0 \end{bmatrix}.

Ahora las ecuaciones son

\theta_1+\theta_3=2, \qquad \theta_2+\theta_3=1.

Sea $\theta_3=t$ la variable libre. Entonces

\theta_1=2-t, \qquad \theta_2=1-t, \qquad \theta_3=t.

Cada valor de $t$ produce un vector de parámetros que da el mismo lado derecho. Por ejemplo, $t=0$ da $(2,1,0)$ , mientras que $t=1$ da $(1,0,1)$ . Ambos satisfacen las tres ecuaciones originales. Las predicciones del modelo están fijadas, pero los pesos individuales no son identificables a partir de estas observaciones por sí solas.

Una fila de ceros es diferente de una contradicción

La última fila del ejemplo se convierte en

0\theta_1+0\theta_2+0\theta_3=0.

Esa fila es redundante, por lo que no aporta una restricción nueva. No la confundas con

0\theta_1+0\theta_2+0\theta_3=5,

que es imposible. En una matriz aumentada, una fila con ceros a la izquierda y un lado derecho distinto de cero indica incompatibilidad y, por tanto, ausencia de solución. La misma matriz del lado izquierdo puede admitir infinitas soluciones, una solución o ninguna, según el lado derecho transformado.

Esta distinción importa en las canalizaciones de datos. Las filas repetidas o dependientes pueden reducir la cantidad de evidencia independiente sin hacer contradictorias las ecuaciones. Una fila contradictoria, en cambio, indica que las observaciones no pueden explicarse exactamente mediante el modelo lineal propuesto.

Implementa la búsqueda de pivotes en NumPy

La implementación compacta siguiente utiliza pivoteo parcial. En cada columna elige el candidato de mayor magnitud por debajo de la fila pivote actual, lo intercambia para colocarlo en su sitio, normaliza el pivote y elimina las entradas que están debajo. La tolerancia evita tratar como pivote real un valor que solo sea ruido de redondeo.

import numpy as np

def row_echelon(matrix, tolerance=1e-12):
    a = np.array(matrix, dtype=float, copy=True)
    rows, columns = a.shape
    pivot_row = 0
    pivot_columns = []

    for column in range(columns):
        if pivot_row == rows:
            break

        candidate = pivot_row + np.argmax(np.abs(a[pivot_row:, column]))
        if abs(a[candidate, column]) <= tolerance:
            continue

        a[[pivot_row, candidate]] = a[[candidate, pivot_row]]
        a[pivot_row] /= a[pivot_row, column]

        for row in range(pivot_row + 1, rows):
            a[row] -= a[row, column] * a[pivot_row]

        a[np.abs(a) <= tolerance] = 0
        pivot_columns.append(column)
        pivot_row += 1

    return a, pivot_columns


features = np.array([
    [1, 2, 3],
    [2, 4, 6],
    [1, 1, 2],
])

echelon, pivots = row_echelon(features)
print(echelon)
print(pivots)
print(np.linalg.matrix_rank(features))

La salida significativa es aproximadamente

[[1. 2. 3.]
 [0. 1. 1.]
 [0. 0. 0.]]
[0, 1]
2

Los decimales exactos dependen del tipo de datos y de la tolerancia, pero la conclusión estructural es estable aquí: dos columnas pivote y una columna libre. matrix_rank de NumPy también usa una tolerancia alrededor de los valores singulares, en lugar de preguntar si un valor de coma flotante es literalmente igual a cero. Por eso, una decisión sobre el rango debe informarse junto con su escala y tolerancia, no como una verdad eterna sobre mediciones ruidosas.

Qué significa esto para un modelo de IA

Supón que un modelo lineal calcula

\hat{y}=\theta_1f_1+\theta_2f_2+\theta_3f_3.

Cuando $f_3=f_1+f_2$ , la predicción se convierte en

\hat{y}=(\theta_1+\theta_3)f_1+(\theta_2+\theta_3)f_2.

En este diseño solo son observables las sumas $\theta_1+\theta_3$ y $\theta_2+\theta_3$ . Por tanto, distintos vectores de parámetros pueden producir predicciones idénticas en todas las filas de la matriz. Un entrenamiento aún puede devolver un conjunto de pesos porque el optimizador, la inicialización, el regularizador o la trayectoria numérica selecciona un punto de la familia. Ese punto seleccionado no demuestra que los datos hayan identificado la contribución independiente de cada característica.

Usa la forma escalonada por filas como diagnóstico, no como sustituto de la validación. Un cálculo del rango sobre una muestra pequeña puede cambiar cuando cambian el preprocesamiento, el escalado, el tratamiento de valores ausentes o los datos nuevos. Para una matriz más grande o ruidosa, inspecciona también la escala de los valores singulares y el número de condición. Una matriz de rango completo aún puede estar casi en dependencia, lo que hace que su solución sea sensible a pequeños cambios en las mediciones.

condition = np.linalg.cond(features)
residual = np.linalg.norm(features[:, 2] - features[:, 0] - features[:, 1])
print(condition, residual)

Aquí el residuo es exactamente cero en los valores almacenados y el número de condición es extremadamente grande en aritmética de coma flotante (aproximadamente $3.8\times10^{16}$ en esta ejecución). Una matriz exactamente deficiente en rango tiene un número de condición matemático infinito, pero una SVD de coma flotante puede informar de un valor finito muy grande. Ese contraste es una advertencia en sí mismo. En datos de producción, usa una tolerancia consciente de la escala: un residuo diminuto puede indicar una dependencia casi exacta genuina o simplemente una medición por debajo de la precisión relevante para la aplicación.