Tous les défis
Moyen 0 résolus 0 % de réussite

Régression linéaire par descente de gradient

Apprenez la pente et l'ordonnée à l'origine d'une droite en descendant pas à pas l'erreur quadratique moyenne.

Ce que vous allez apprendre

  • Minimiser l'erreur quadratique moyenne pas à pas
  • Calculer les gradients de la pente et de l'ordonnée
  • Voir l'effet du taux d'apprentissage sur l'entraînement

Problème

Au lieu d'une formule, entraînez la droite y = w × x + b par descente de gradient par lots sur l'erreur quadratique moyenne MSE = Σ(w × x + b - y)² / n.

Partez de w = 0 et b = 0. À chaque époque, en utilisant tous les points :

  1. errorᵢ = w × xᵢ + b - yᵢ
  2. dw = (2 / n) × Σ errorᵢ × xᵢ et db = (2 / n) × Σ errorᵢ
  3. w ← w - learning_rate × dw et b ← b - learning_rate × db (tous deux calculés à partir des mêmes erreurs)

Implémentez train_linear_regression(xs, ys, learning_rate, epochs).

Entrée

xs, ys : les points de données (même longueur).

learning_rate, epochs : le pas et le nombre de mises à jour.

Sortie

Renvoyez [w, b] après l'entraînement.

Contraintes

1 ≤ nombre de points ≤ 1 000, 0 ≤ epochs ≤ 10 000

0 < learning_rate ≤ 1

-100 ≤ chaque valeur ≤ 100

Exemples

Exemple 1
Entrée :
xs = [1.0, 2.0]
ys = [2.0, 4.0]
epochs = 1
learning_rate = 0.1

Sortie attendue :
expected = [1.0, 0.6]
Entrée :
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;

Sortie attendue :
std::vector<double> expected = {1.0, 0.6};
Entrée :
double[] xs = new double[] {1.0, 2.0};
double[] ys = new double[] {2.0, 4.0};
long epochs = 1;
double learning_rate = 0.1;

Sortie attendue :
double[] expected = new double[] {1.0, 0.6};

Explication

Avec w = b = 0, les erreurs valent -2 et -4. dw = (2 / 2) × (-2×1 - 4×2) = -10 et db = (2 / 2) × (-2 - 4) = -6, donc w = 0 - 0.1 × (-10) = 1 et b = 0 - 0.1 × (-6) = 0.6. Résultat : [1, 0.6].

Exemple 2
Entrée :
xs = [1.0, 2.0, 3.0]
ys = [3.0, 5.0, 7.0]
epochs = 2000
learning_rate = 0.05

Sortie attendue :
expected = [2.0, 1.0]
Entrée :
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;

Sortie attendue :
std::vector<double> expected = {2.0, 1.0};
Entrée :
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;

Sortie attendue :
double[] expected = new double[] {2.0, 1.0};

Explication

Les données sont sur y = 2x + 1. Après 2 000 époques, la descente de gradient a convergé vers w = 2 et b = 1, la même réponse que la formule des moindres carrés.

Références

Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.

Apprenez des autres

Solutions de la communauté

Aucune solution publiée pour l'instant. Résolvez ce défi pour partager la première.