Un premier modèle qui apprend ses poids#

Dans la leçon précédente, nous sommes partis de quelques variables Python pour arriver progressivement à des données associées à un résultat attendu.

Nous avions :

• température
• humidité
• données
• oui / non

Nous avons ensuite calculé un seuil à partir des températures. Utilisons maintenant les deux caractéristiques.

1. Nos données d’apprentissage#

Reprenons les mêmes observations :

donnees = [
    ([22, 70], 0),
    ([24, 65], 0),
    ([27, 42], 1),
    ([29, 35], 1),
    ([25, 55], 0),
]

Nous avons simplement remplacé non par 0 et oui par 1.

Notre dataset signifie :

• [22, 70] → 0
• [24, 65] → 0
• [27, 42] → 1
• [29, 35] → 1
• [25, 55] → 0

Nous pouvons maintenant parler de classification :

• 0 → ne pas arroser
• 1 → arroser

2. Le modèle#

Avant d’écrire la fonction Python, décrivons le calcul :

Le modèle possède deux poids et un biais :

poids_temperature = 0.0
poids_humidite = 0.0
biais = 0.0

Le calcul est :

score =
    température × poids_température
    + humidité × poids_humidité
    + biais

Puis :

• score >= 0 → 1
• score < 0 → 0

def prediction(temperature, humidite):
    score = (
        temperature * poids_temperature
        + humidite * poids_humidite
        + biais
    )

    if score >= 0:
        return 1
    else:
        return 0

3. Au départ, les poids sont nuls#

Nous commençons avec :

• poids température = 0
• poids humidité = 0
• biais = 0

Le score commence donc à 0 pour chaque observation.

Il faut maintenant donner au modèle l’occasion d’apprendre.

4. Comment apprendre ?#

Parcourons les données plusieurs fois. Chaque parcours est appelé une epoch.

Pour chaque observation, le modèle :

• calcule une prédiction ;
• compare la prédiction avec la réponse attendue ;
• calcule une erreur ;
• modifie ses paramètres lorsque c’est nécessaire.

Dans notre expérience :

erreur = label - resultat

Une prédiction correcte donne 0. Une erreur donne une valeur différente de 0 et déclenche un ajustement.

5. La modification des poids#

poids_temperature += (
    taux_apprentissage
    * erreur
    * temperature
)

poids_humidite += (
    taux_apprentissage
    * erreur
    * humidite
)

biais += taux_apprentissage * erreur

Notre taux d’apprentissage est :

taux_apprentissage = 0.01

Le modèle modifie donc progressivement ses paramètres selon les exemples rencontrés.

6. Le programme complet#

Puis sa traduction directe en Python :

# ==========================================
# Leçon 2.2
# Premier modèle qui apprend ses poids
# ==========================================

donnees = [
    ([22, 70], 0),
    ([24, 65], 0),
    ([27, 42], 1),
    ([29, 35], 1),
    ([25, 55], 0),
]

poids_temperature = 0.0
poids_humidite = 0.0
biais = 0.0
taux_apprentissage = 0.01


def prediction(temperature, humidite):
    score = (
        temperature * poids_temperature
        + humidite * poids_humidite
        + biais
    )

    if score >= 0:
        return 1
    else:
        return 0


for epoch in range(100):
    erreurs = 0

    for features, label in donnees:
        temperature = features[0]
        humidite = features[1]

        resultat = prediction(temperature, humidite)
        erreur = label - resultat

        if erreur != 0:
            erreurs += 1

            poids_temperature += (
                taux_apprentissage
                * erreur
                * temperature
            )

            poids_humidite += (
                taux_apprentissage
                * erreur
                * humidite
            )

            biais += taux_apprentissage * erreur

    print(
        "Epoch :", epoch + 1,
        "| erreurs :", erreurs
    )

    if erreurs == 0:
        break


print()
print("=== Modèle appris ===")
print("Poids température :", poids_temperature)
print("Poids humidité    :", poids_humidite)
print("Biais              :", biais)

temperature = 28
humidite = 40
resultat = prediction(temperature, humidite)

print()
print("=== Nouvelle observation ===")
print("Température :", temperature, "°C")
print("Humidité    :", humidite, "%")

if resultat == 1:
    print("Prédiction : arroser")
else:
    print("Prédiction : ne pas arroser")

7. Le modèle apprend quelque chose#

L’expérience observée donne :

• Epoch 1 → 4 erreurs
• Epoch 2 → 2 erreurs
• Epoch 3 → 1 erreur
• Epoch 4 → 0 erreur

Les paramètres obtenus sont :

• poids température : 0.38
• poids humidité : -0.19
• biais : 0.01

Notre modèle calcule donc :

score =
    température × 0.38
    + humidité × (-0.19)
    + 0.01

8. Regardons ce que les poids signifient#

• Le poids de la température est positif : +0.38. Une température plus élevée augmente le score.
• Le poids de l’humidité est négatif : -0.19. Une humidité plus élevée diminue le score.
• Ces relations viennent des exemples fournis au modèle.

Le modèle a modifié ses paramètres afin de réduire ses erreurs. C’est ici que nous commençons réellement à voir la différence entre une règle programmée et un modèle appris.

9. Une nouvelle observation#

Testons :

• température = 28 °C
• humidité = 40 %

Le modèle calcule :

score = 28 × 0.38
      + 40 × (-0.19)
      + 0.01
      = 3.05

Comme 3.05 >= 0, le modèle prédit arroser.

Avec 22 °C et 70 % :

score = 22 × 0.38
      + 70 × (-0.19)
      + 0.01
      = -4.93

Le modèle prédit ne pas arroser.

10. Nous avons maintenant une frontière de décision#

Notre modèle sépare les deux catégories selon :

• score >= 0 → arroser
• score < 0 → ne pas arroser

La frontière est donnée par :

0.38 × température
- 0.19 × humidité
+ 0.01 = 0

Elle dépend de trois paramètres appris :

• poids température ;
• poids humidité ;
• biais.

11. Mais comment le modèle sait-il quoi modifier ?#

Nous avons utilisé une règle d’erreur simple :

erreur = label - resultat

Puis nous avons directement modifié les poids.

C’est une excellente manière de découvrir le principe. Cherchons maintenant une méthode plus générale pour mesurer l’erreur : une fonction de perte.

La question devient alors :

Comment savoir dans quelle direction modifier un poids pour faire diminuer cette perte ?

C’est là qu’apparaît la descente de gradient.

Pour comprendre ce mécanisme sans nous perdre immédiatement dans les deux poids de notre modèle d’arrosage, repartons sur un problème plus simple :

x → y

avec un seul poids.

La prochaine étape consiste à comprendre comment une machine peut progressivement trouver :

w ≈ 2

à partir de quelques exemples.