1. Conceptos teóricos

En álgebra lineal, una base de un espacio vectorial V es un conjunto de vectores linealmente independientes que generan V. La dimensión de V es el número de vectores en cualquier base de V. El algoritmo base‑dimensión consiste en:

1. Construir una matriz cuyas columnas sean los vectores dados.
2. Aplicar eliminación de Gauss‑Jordan (o SVD) para obtener una forma escalonada.
3. Identificar columnas pivote: esas columnas forman una base.
4. Contar pivotes: ese número es la dimensión.

Este proceso es esencial en:

• Reducción de características en Machine Learning.
• Resolución de sistemas lineales.
• Determinación de rangos y nulidades de matrices.

2. Implementación en Python

Usaremos NumPy para la manipulación de matrices y SymPy para obtener bases simbólicas cuando se requiera precisión exacta.

2.1. Versión NumPy (numérica)

import numpy as np
def base_y_dimension(matrix: np.ndarray):
    """Devuelve la base (columnas pivote) y la dimensión de la matriz.
    Parámetros
    ----------
    matrix : np.ndarray
        Matriz cuyas columnas son los vectores del subespacio.
    Retorna
    -------
    base_indices : list[int]
        Índices de columnas que forman una base.
    dimension : int
        Número de vectores base (rango de la matriz).
    """
    # Paso 1: reducción a forma escalonada por filas (rref)
    rref, pivots = _rref(matrix)
    return pivots, len(pivots)
def _rref(A, tol=1e-12):
    """Calcula la forma reducida por filas (RREF) y devuelve los pivotes.
    Implementación ligera basada en eliminación de Gauss‑Jordan.
    """
    A = A.astype(float).copy()
    m, n = A.shape
    pivots = []
    row = 0
    for col in range(n):
        # buscar pivote
        max_row = np.argmax(np.abs(A[row:, col])) + row
        if abs(A[max_row, col]) < tol:
            continue
        # intercambiar filas
        A[[row, max_row]] = A[[max_row, row]]
        pivots.append(col)
        # normalizar fila pivote
        A[row] = A[row] / A[row, col]
        # eliminar otras filas
        for r in range(m):
            if r != row:
                A[r] -= A[r, col] * A[row]
        row += 1
        if row == m:
            break
    return A, pivots
# Ejemplo de uso
M = np.array([[1, 2, 3],
              [2, 4, 6],
              [1, 1, 0]], dtype=float)
base_idx, dim = base_y_dimension(M)
print("Índices de base:", base_idx)
print("Dimensión:", dim)

Salida esperada:

Índices de base: [0, 2]
Dimensión: 2

Los vectores columna 0 y 2 son linealmente independientes y generan el subespacio.

2.2. Versión SymPy (exacta)

import sympy as sp
def base_y_dimension_sympy(matrix):
    A = sp.Matrix(matrix)
    rref, pivots = A.rref()
    base_vectors = [A[:, i] for i in pivots]
    return base_vectors, len(pivots)
# Ejemplo exacto
M_sym = [[1, 2, 3],
         [2, 4, 6],
         [1, 1, 0]]
base_vecs, dim = base_y_dimension_sympy(M_sym)
print("Base simbólica:")
for v in base_vecs:
    sp.pprint(v)
print("Dimensión:", dim)

Este enfoque es útil cuando los datos son racionales o se necesita una prueba formal.

3. Comparativa de enfoques

En entornos de Machine Learning se prefiere la versión numérica, mientras que para verificación formal se escoge SymPy.

4. Buenas prácticas, seguridad y troubleshooting

4.1. Pre‑procesamiento

• Normaliza los vectores (p.ej., v / np.linalg.norm(v)) para mejorar la estabilidad numérica.
• Elimina filas/columnas nulas antes de la reducción.

4.2. Detección de problemas comunes

• Rangos inesperados: Verifica que la tolerancia tol sea adecuada al rango de los datos.
• Overflow/underflow: Usa np.float64 o np.longdouble si trabajas con valores extremos.

4.3. Seguridad

Al recibir matrices de fuentes externas, valida dimensiones y tipos para evitar ataques de denegación de servicio (DoS) mediante matrices extremadamente densas.

4.4. Optimización de rendimiento

• Para matrices muy grandes, emplea scipy.sparse.linalg.spsolve y scipy.sparse.linalg.lsqr en lugar de la versión densa.
• Paraleliza la fase de pivoteo usando numba o cupy si dispones de GPU.

5. Caso de uso: reducción de dimensiones en un dataset de imágenes

Supongamos que tenemos un conjunto de 10.000 vectores de características de 256 dimensiones extraídas con un modelo ResNet‑50. Queremos obtener la base del subespacio que captura el 95 % de la varianza.

import numpy as np
from sklearn.decomposition import PCA
# Simulación de datos
X = np.random.rand(10000, 256)
# PCA para obtener componentes principales
pca = PCA(n_components=0.95, svd_solver='full')
X_reduced = pca.fit_transform(X)
print('Componentes retenidos:', pca.n_components_)
print('Dimensión del subespacio:', pca.n_components_)

En este caso, PCA internamente calcula la base ortonormal del subespacio mediante SVD, una alternativa robusta al algoritmo base‑dimensión tradicional.

Conclusión

El algoritmo base y dimensión es una herramienta fundamental en álgebra lineal que permite comprender la estructura de cualquier subespacio vectorial. Con Python disponemos de dos vías principales: una numérica (NumPy) para rendimiento y una simbólica (SymPy) para exactitud. La elección depende del caso de uso, la escala de los datos y la necesidad de precisión.

Al combinar este algoritmo con técnicas modernas como PCA, SVD o métodos de reducción esparsa, los ingenieros pueden crear pipelines de datos más eficientes y confiables.