1. ¿Qué es el algoritmo de mínimos cuadrados?

El método de mínimos cuadrados (OLS – Ordinary Least Squares) busca encontrar los parámetros de un modelo lineal que minimizan la suma de los errores cuadráticos entre los valores observados y los predichos. Formalmente, para un conjunto de datos \((X, y)\) se resuelve:

\[ \hat{\beta}=\arg\min_{\beta}\;\|y-X\beta\|_2^2 \]

Donde β son los coeficientes a estimar. La solución cerrada, cuando X tiene rango completo, es:

\[ \hat{\beta} = (X^{T}X)^{-1}X^{T}y \]

Esta fórmula es la base de cientos de aplicaciones: regresión lineal, calibración de sensores, análisis de series temporales, etc.

2. Implementación paso a paso en Python

Usaremos numpy para la solución directa y scikit‑learn para una API más amigable.

2.1. Preparación del entorno

pip install numpy scikit-learn matplotlib pandas

2.2. Datos de ejemplo

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Generamos datos sintéticos
def synthetic_data(n=100, noise=0.5):
    np.random.seed(42)
    X = 2 * np.random.rand(n, 1)          # característica única
    y = 4 + 3 * X + np.random.randn(n, 1) * noise
    return X, y
X, y = synthetic_data()

2.3. Solución con la fórmula cerrada (NumPy)

# Añadimos la columna de bias (intercepto)
X_b = np.c_[np.ones((X.shape[0], 1)), X]  # shape (n, 2)
# Cálculo de betâ = (XᵀX)⁻¹ Xᵀy
beta_hat = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
print("Coeficientes estimados:", beta_hat.ravel())

2.4. Solución usando Scikit‑learn

from sklearn.linear_model import LinearRegression
model = LinearRegression()
model.fit(X, y)
print("Intercepto:", model.intercept_[0])
print("Pendiente:", model.coef_[0][0])

2.5. Visualización del ajuste

plt.scatter(X, y, color='steelblue', label='Datos')
X_plot = np.linspace(0, 2, 100).reshape(-1, 1)
plt.plot(X_plot, model.predict(X_plot), "r-", linewidth=2, label='Regresión OLS')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Ajuste por Mínimos Cuadrados')
plt.legend()
plt.show()

3. Comparativa con técnicas relacionadas

from sklearn.linear_model import Ridge, Lasso
ridge = Ridge(alpha=1.0).fit(X, y)
lasso = Lasso(alpha=0.1).fit(X, y)

from sklearn.svm import SVR
svr = SVR(kernel='rbf', C=100, epsilon=0.1).fit(X, y.ravel())

4. Buenas prácticas, rendimiento y troubleshooting

4.1. Verificar supuestos

• Linealidad: La relación entre predictores y respuesta debe ser aproximadamente lineal.
• Homoscedasticidad: Varianza constante del error.

  import statsmodels.api as sm
  res = sm.OLS(y, X_b).fit()
  sm.graphics.plot_regress_exog(res, 1)
  plt.show()
  

• Independencia de errores y normalidad (para inferencia).

4.2. Manejo de multicolinealidad

Utiliza el factor de inflación de la varianza (VIF) para detectar colinealidad.

from statsmodels.stats.outliers_influence import variance_inflation_factor
vif = [variance_inflation_factor(X_b, i) for i in range(X_b.shape[1])]
print(vif)

Si VIF > 10, considera eliminar o combinar variables o cambiar a Ridge.

4.3. Optimización para grandes volúmenes de datos

• Usa numpy.linalg.lstsq que emplea SVD y es más estable que la inversión directa.
• Para datasets que no caben en memoria, emplea scikit‑learn con SGDRegressor (optimización estocástica).

from sklearn.linear_model import SGDRegressor
sgd = SGDRegressor(max_iter=1000, tol=1e-3)
sgd.fit(X, y.ravel())

4.4. Seguridad y validación de entrada

Siempre valida los tipos y rangos de los datos antes de pasar a la regresión, especialmente en APIs públicas:

def validate_input(arr):
    if not isinstance(arr, np.ndarray):
        raise TypeError('Se requiere un numpy.ndarray')
    if np.isnan(arr).any():
        raise ValueError('Los datos contienen NaN')
    return arr

5. Caso de estudio: Predicción de consumo energético

Supongamos que una empresa quiere estimar el consumo de energía (kWh) en función de la temperatura exterior y la ocupación del edificio.

import pandas as pd
# Dataset ficticio
url = "https://raw.githubusercontent.com/selva86/datasets/master/EnergyConsumption.csv"
df = pd.read_csv(url)
X = df[["Temperature", "Occupancy"]].values
y = df[["Energy"]].values
# Escalado (muy importante para la condición numérica)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# OLS con NumPy (añadiendo bias)
Xb = np.c_[np.ones((X_scaled.shape[0], 1)), X_scaled]
beta = np.linalg.lstsq(Xb, y, rcond=None)[0]
print("Beta estimado:", beta.ravel())

Los coeficientes nos indican cuánto varía el consumo por cada grado Celsius y por cada persona adicional. Con esta información la empresa puede diseñar estrategias de ahorro.

6. Conclusiones

• El algoritmo de mínimos cuadrados es la piedra angular de la regresión lineal y sigue siendo la primera opción por su simplicidad y velocidad.
• Python ofrece múltiples caminos: solución directa con numpy, API de alto nivel con scikit‑learn, y herramientas estadísticas con statsmodels.
• Cuando los supuestos clásicos fallan, considera regularización (Ridge/Lasso) o métodos no lineales (SVR, árboles).
• Para big data, emplea algoritmos iterativos (SGD) o técnicas de reducción de dimensionalidad (PCA) antes de aplicar OLS.