Escribir una regresión lineal múltiple desde cero

Integra operaciones matriciales + descenso de gradiente + MSE y recorre por completo el flujo completo de «datos → modelo → entrenamiento → predicción».

Después de completar este caso, entenderás:Un modelo de aprendizaje automático que funciona es, en esencia, una combinación de álgebra lineal + cálculo + optimización.


Introducción desde la vida cotidiana

Estimación del precio de la vivienda: no solo importa el área

El precio de la vivienda no solo depende del área, sino también del número de habitaciones, la planta, la cercanía al metro, la antigüedad... Cada factor tiene su propio peso.

La regresión lineal múltiple consiste en:Asignar a cada factor un peso w, multiplicar todos los factores por sus pesos, sumarlos y añadir un precio base b.Luego, usando datos históricos de transacciones, se deducen estos pesos: eso es el entrenamiento.


Comprensión intuitiva

El ciclo completo de cinco pasos del aprendizaje automático:

Preparar los datos
X, y
Propagación hacia adelante
X*W+b
Calcular la pérdida
MSE
Calcular el gradiente
X.T*error
Actualizar los parámetros
W-=lr*dW

Estos cinco pasos se ejecutan en bucle en cada iteración hasta que la pérdida converge. El método fit() de PyTorch/TensorFlow implementa internamente este bucle.


Definición matemática

\[ \hat{y} = XW + b, \quad L = \frac{1}{n}\sum(\hat{y}_i - y_i)^2 \] \[ \frac{\partial L}{\partial W} = \frac{2}{n} X^T (XW + b - y), \quad \frac{\partial L}{\partial b} = \frac{2}{n} \sum (XW + b - y) \]

Puesta en práctica con Python

Ejemplo

import numpy as np
np.random.seed(0)


class LinearRegressionFromScratch:
    """Implementación completamente con operaciones matriciales de NumPy + descenso de gradiente"""

    def __init__(self, lr=0.01, epochs=500):
        self.lr = lr
        self.epochs = epochs
        self.W = None
        self.b = None
        self.loss_history = []

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.W = np.zeros(n_features)
        self.b = 0.0

        for epoch in range(self.epochs):
            y_pred = X @ self.W + self.b
            error = y_pred - y
            loss = np.mean(error ** 2)
            self.loss_history.append(loss)

            dW = (2 / n_samples) * (X.T @ error)
            db = (2 / n_samples) * np.sum(error)

            self.W -= self.lr * dW
            self.b -= self.lr * db

            if epoch % 100 == 0:
                print(f"EJEMPLO epoch {epoch:4d}  loss={loss:.4f}")

    def predict(self, X):
        return X @ self.W + self.b


# Construcción de datos: y = 3*x1 - 2*x2 + 5 + ruido
X = np.random.uniform(-5, 5, size=(200, 2))
true_W = np.array([3.0, -2.0])
true_b = 5.0
y = X @ true_W + true_b + np.random.randn(200) * 1.5

model = LinearRegressionFromScratch(lr=0.01, epochs=500)
model.fit(X, y)

print(f"\n"EJEMPLO aprendió: W={np.round(model.W, 3)}, b={round(model.b, 3)}")
print(f"Real: W={true_W}, b={true_b}")
print(f"Pérdida: {model.loss_history)

# Predecir nuevas muestras
X_new = np.array([[1.0, 1.0], [-2.0, 3.0]])
print(f"Predicción: {np.round(model.predict(X_new), 2)}")
EJEMPLO epoch    0  loss=157.0828
EJEMPLO epoch  100  loss=2.6062
EJEMPLO epoch  200  loss=2.3077
EJEMPLO epoch  300  loss=2.2581
EJEMPLO epoch  400  loss=2.2475

EJEMPLO 学到的: W=[ 3.014 -2.017], b=4.737
真实的:       W=[ 3. -2.], b=5.0
损失: 157.1 -> 2.25
预测: [5.73 -4.18]

Escenarios de aplicación en IA

EscenarioRelación con este caso
Modelo baseLa primera versión de cualquier tarea de regresión debería ser una regresión lineal: simple e interpretable.
Última capa de la red neuronalLa capa de salida de muchas redes es una capa lineal; en esencia, es una regresión lineal.
Análisis de importancia de característicasDespués del entrenamiento, observa la magnitud de W: las características con mayor valor absoluto tienen mayor impacto en el resultado.
Otras extensiones