Todos los desafíos
Intermedio 0 resueltos 0% de aceptación

Regresión lineal con descenso de gradiente

Aprende la pendiente y la ordenada al origen de una recta bajando paso a paso por el error cuadrático medio.

Lo que aprenderás

  • Minimizar el error cuadrático medio paso a paso
  • Calcular gradientes de pendiente y ordenada
  • Ver cómo afecta la tasa de aprendizaje al entrenamiento

Problema

Ver original (inglés)

En lugar de una fórmula, entrena la recta y = w × x + b con descenso de gradiente por lotes sobre el error cuadrático medio MSE = Σ(w × x + b - y)² / n.

Empieza con w = 0 y b = 0. En cada época, usando todos los puntos:

  1. errorᵢ = w × xᵢ + b - yᵢ
  2. dw = (2 / n) × Σ errorᵢ × xᵢ y db = (2 / n) × Σ errorᵢ
  3. w ← w - learning_rate × dw y b ← b - learning_rate × db (ambos calculados con los mismos errores)

Implementa train_linear_regression(xs, ys, learning_rate, epochs).

Entrada

xs, ys: Los puntos de datos (misma longitud).

learning_rate, epochs: El tamaño del paso y el número de actualizaciones.

Salida

Devuelve [w, b] después del entrenamiento.

Restricciones

1 ≤ número de puntos ≤ 1000, 0 ≤ epochs ≤ 10 000

0 < learning_rate ≤ 1

-100 ≤ cada valor ≤ 100

Ejemplos

Ejemplo 1
Entrada:
xs = [1.0, 2.0]
ys = [2.0, 4.0]
epochs = 1
learning_rate = 0.1

Salida esperada:
expected = [1.0, 0.6]
Entrada:
std::vector<double> xs = {1.0, 2.0};
std::vector<double> ys = {2.0, 4.0};
long long epochs = 1;
double learning_rate = 0.1;

Salida esperada:
std::vector<double> expected = {1.0, 0.6};
Entrada:
double[] xs = new double[] {1.0, 2.0};
double[] ys = new double[] {2.0, 4.0};
long epochs = 1;
double learning_rate = 0.1;

Salida esperada:
double[] expected = new double[] {1.0, 0.6};

Explicación

Con w = b = 0, los errores son -2 y -4. dw = (2 / 2) × (-2×1 - 4×2) = -10 y db = (2 / 2) × (-2 - 4) = -6, así que w = 0 - 0.1 × (-10) = 1 y b = 0 - 0.1 × (-6) = 0.6. Resultado: [1, 0.6].

Ejemplo 2
Entrada:
xs = [1.0, 2.0, 3.0]
ys = [3.0, 5.0, 7.0]
epochs = 2000
learning_rate = 0.05

Salida esperada:
expected = [2.0, 1.0]
Entrada:
std::vector<double> xs = {1.0, 2.0, 3.0};
std::vector<double> ys = {3.0, 5.0, 7.0};
long long epochs = 2000;
double learning_rate = 0.05;

Salida esperada:
std::vector<double> expected = {2.0, 1.0};
Entrada:
double[] xs = new double[] {1.0, 2.0, 3.0};
double[] ys = new double[] {3.0, 5.0, 7.0};
long epochs = 2000;
double learning_rate = 0.05;

Salida esperada:
double[] expected = new double[] {2.0, 1.0};

Explicación

Los datos están sobre y = 2x + 1. Tras 2000 épocas, el descenso de gradiente converge a w = 2 y b = 1, la misma respuesta que la fórmula de mínimos cuadrados.

Referencias

Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.

Aprende de otros

Soluciones de la comunidad

Aún no hay soluciones publicadas. Resuelve este reto para compartir la primera.