Problema
La discesa del gradiente a mini-batch è il modo in cui si addestra quasi ogni rete neurale: dividi i dati in piccoli batch e aggiorna i pesi dopo ciascuno.
Addestra y = w × x + b sull'errore quadratico medio, partendo da w = 0 e b = 0. A ogni epoca, dividi gli esempi in ordine in batch di batch_size (l'ultimo batch può essere più piccolo). Per ogni batch di dimensione n:
- errorᵢ = w × xᵢ + b - yᵢ per ogni esempio del batch
- dw = (2 / n) × Σ errorᵢ × xᵢ e db = (2 / n) × Σ errorᵢ
- w ← w - learning_rate × dw e b ← b - learning_rate × db
Implementa train_mini_batch(xs, ys, batch_size, learning_rate, epochs).
Input
xs, ys: I punti dati (stessa lunghezza).
batch_size: Esempi per batch.
learning_rate, epochs: La dimensione del passo e il numero di passate sui dati.
Output
Restituisci [w, b] dopo l'addestramento.
Vincoli
1 ≤ numero di punti ≤ 1.000, 1 ≤ batch_size ≤ numero di punti, 0 ≤ epochs ≤ 1.000
0 < learning_rate ≤ 1
-100 ≤ ogni valore ≤ 100
Esempi
Input:
xs = [1.0, 2.0, 3.0]
ys = [2.0, 4.0, 6.0]
epochs = 1
batch_size = 2
learning_rate = 0.1
Output atteso:
expected = [2.44, 1.08]Input:
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;
Output atteso:
std::vector<double> expected = {2.44, 1.08};Input:
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;
Output atteso:
double[] expected = new double[] {2.44, 1.08};Spiegazione
Il batch 1 è x = [1, 2]: errori -2 e -4, dw = -10, db = -6, quindi w = 1 e b = 0.6. Il batch 2 è x = [3] da solo: errore 1×3 + 0.6 - 6 = -2.4, dw = 2 × (-2.4) × 3 = -14.4 e db = -4.8, quindi w = 2.44 e b = 1.08. Risultato: [2.44, 1.08].
Input:
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
Output atteso:
expected = [1.75, 0.6]Input:
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;
Output atteso:
std::vector<double> expected = {1.75, 0.6};Input:
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;
Output atteso:
double[] expected = new double[] {1.75, 0.6};Spiegazione
Un batch grande quanto il dataset è la normale discesa del gradiente a batch: un aggiornamento per epoca. Risultato: [1.75, 0.6].
Come affrontarlo
Prova prima da solo, poi apri un suggerimento alla volta.
Suggerimento 1
Processa i campioni nell'ordine dato, aggiornando i parametri dopo ogni batch invece che dopo ogni singolo punto.
Suggerimento 2
Per ogni batch, calcola prima gli errori di previsione, poi usa le loro medie con i valori di x per ottenere i due gradienti.
Suggerimento 3
L'ultimo batch può essere più קטן degli altri, quindi il suo scaling del gradiente deve usare la dimensione di quel batch.
Complessità attesa
tempo O(epochs × n), spazio aggiuntivo O(1)
Riferimenti
Questa sfida è adattata per CodeUtility. Segui la traccia e i vincoli sopra.