Problema
El descenso de gradiente por mini-lotes es la forma en que se entrena casi toda red neuronal: divide los datos en lotes pequeños y actualiza los pesos después de cada uno.
Entrena y = w × x + b con el error cuadrático medio, empezando con w = 0 y b = 0. En cada época, divide los ejemplos en orden en lotes de batch_size (el último lote puede ser más pequeño). Para cada lote de tamaño n:
- errorᵢ = w × xᵢ + b - yᵢ para cada ejemplo del lote
- dw = (2 / n) × Σ errorᵢ × xᵢ y db = (2 / n) × Σ errorᵢ
- w ← w - learning_rate × dw y b ← b - learning_rate × db
Implementa train_mini_batch(xs, ys, batch_size, learning_rate, epochs).
Entrada
xs, ys: Los puntos de datos (misma longitud).
batch_size: Ejemplos por lote.
learning_rate, epochs: El tamaño del paso y el número de pasadas sobre los datos.
Salida
Devuelve [w, b] después del entrenamiento.
Restricciones
1 ≤ número de puntos ≤ 1.000, 1 ≤ batch_size ≤ número de puntos, 0 ≤ epochs ≤ 1.000
0 < learning_rate ≤ 1
-100 ≤ cada valor ≤ 100
Ejemplos
Entrada:
xs = [1.0, 2.0, 3.0]
ys = [2.0, 4.0, 6.0]
epochs = 1
batch_size = 2
learning_rate = 0.1
Salida esperada:
expected = [2.44, 1.08]Entrada:
std::vector<double> xs = {1.0, 2.0, 3.0};
std::vector<double> ys = {2.0, 4.0, 6.0};
long long epochs = 1;
long long batch_size = 2;
double learning_rate = 0.1;
Salida esperada:
std::vector<double> expected = {2.44, 1.08};Entrada:
double[] xs = new double[] {1.0, 2.0, 3.0};
double[] ys = new double[] {2.0, 4.0, 6.0};
long epochs = 1;
long batch_size = 2;
double learning_rate = 0.1;
Salida esperada:
double[] expected = new double[] {2.44, 1.08};Explicación
El lote 1 es x = [1, 2]: errores -2 y -4, dw = -10, db = -6, así que w = 1 y b = 0.6. El lote 2 es x = [3] solo: error 1×3 + 0.6 - 6 = -2.4, dw = 2 × (-2.4) × 3 = -14.4 y db = -4.8, así que w = 2.44 y b = 1.08. Resultado: [2.44, 1.08].
Entrada:
xs = [1.0, 2.0, 3.0, 4.0]
ys = [3.0, 5.0, 7.0, 9.0]
epochs = 1
batch_size = 4
learning_rate = 0.05
Salida esperada:
expected = [1.75, 0.6]Entrada:
std::vector<double> xs = {1.0, 2.0, 3.0, 4.0};
std::vector<double> ys = {3.0, 5.0, 7.0, 9.0};
long long epochs = 1;
long long batch_size = 4;
double learning_rate = 0.05;
Salida esperada:
std::vector<double> expected = {1.75, 0.6};Entrada:
double[] xs = new double[] {1.0, 2.0, 3.0, 4.0};
double[] ys = new double[] {3.0, 5.0, 7.0, 9.0};
long epochs = 1;
long batch_size = 4;
double learning_rate = 0.05;
Salida esperada:
double[] expected = new double[] {1.75, 0.6};Explicación
Un lote tan grande como el conjunto de datos es el descenso de gradiente por lotes de siempre: una actualización por época. Resultado: [1.75, 0.6].
Cómo abordarlo
Inténtalo primero por tu cuenta y luego abre las pistas una a una.
Pista 1
Procesa las muestras en el orden dado y actualiza los parámetros después de cada batch, no después de cada punto.
Pista 2
Para cada batch, calcula primero los errores de predicción y luego usa sus promedios con los valores de x para obtener los dos gradientes.
Pista 3
El último batch puede ser más pequeño que los demás, así que el escalado del gradiente debe usar el tamaño de ese batch.
Complejidad esperada
tiempo O(epochs × n), espacio extra O(1)
Referencias
Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.