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]
learning_rate = 0.1
epochs = 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};
double learning_rate = 0.1;
long long epochs = 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};
double learning_rate = 0.1;
long epochs = 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]
learning_rate = 0.05
epochs = 2000

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};
double learning_rate = 0.05;
long long epochs = 2000;

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};
double learning_rate = 0.05;
long epochs = 2000;

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.

Comment l'aborder

Essayez d'abord seul, puis ouvrez les indices un par un.

Indice 1

Chaque epoch utilise tous les points pour mesurer à quel point la droite courante est fausse.

Indice 2

Accumulez le gradient de tous les échantillons avant de mettre à jour les deux paramètres ensemble.

Indice 3

Faites attention à ne pas mettre à jour un paramètre trop tôt, car les deux mises à jour doivent utiliser les erreurs du même epoch.

Complexité attendue

temps O(epochs × n), espace supplémentaire O(1)

Références

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

La meilleure solution validée de chaque codeur. Les plus rapides, les plus légères et les mieux notées passent devant.

Aucune solution validée pour l'instant. Résolvez-le et prenez la première place.

Apprenez des autres

Solutions de la communauté

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