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:
X, y
X*W+b
MSE
X.T*error
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
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
| Escenario | Relación con este caso |
|---|---|
| Modelo base | La primera versión de cualquier tarea de regresión debería ser una regresión lineal: simple e interpretable. |
| Última capa de la red neuronal | La capa de salida de muchas redes es una capa lineal; en esencia, es una regresión lineal. |
| Análisis de importancia de características | Después del entrenamiento, observa la magnitud de W: las características con mayor valor absoluto tienen mayor impacto en el resultado. |