Descenso de gradiente por mini-lotes

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:

1. errorᵢ = w × xᵢ + b - yᵢ para cada ejemplo del lote
2. dw = (2 / n) × Σ errorᵢ × xᵢ y db = (2 / n) × Σ errorᵢ
3. 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};

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};

Referencias

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

• Deep Learning book, Chapter 8: Optimization for Training Deep Models
• Stanford CS231n, Neural Networks Part 3: parameter updates