Le neurone - réglage manuel

Qu'est-ce qu'un neurone, vraiment?

Si tu as suivi la Phase 0, tu as déjà deviné une règle : « Si la longueur du pétale dépasse un certain seuil, c'est une Virginica ». C'était une règle dure — oui ou non, noir ou blanc.

Un neurone artificiel fait quelque chose de similaire, mais beaucoup plus nuancé.

Au lieu d'une règle dure, un neurone calcule une probabilité progressive : « Vu ces deux mesures, quelle est la confiance que c'est une Virginica? »

La recette d'un neurone :

1. Prendre les entrées (longueur et largeur du pétale)
2. Peser chacune - décider laquelle est plus importante (poids1, poids2)
3. Additionner le tout - un biais (décalage initial)
4. Appliquer une courbe - la sigmoïde, qui transforme n'importe quel nombre en probabilité entre 0 et 1

Aucune intelligence là-dedans. Juste des multiplications, une addition, et une courbe.

Exemple concret : la température

Avant le code, comprends la recette avec un exemple simple.

Imagine un neurone qui prédit si c'est un jour chaud, basé sur :

• Entrée 1 (x1): L'humidité, normalisée entre 0 et 1. Par ex., 0.6 = 60% d'humidité.
• Entrée 2 (x2): Le rayonnement solaire, normalisé. Par ex., 0.8 = 80% du maximum observé.

Le neurone a déjà des poids (ajustés par entraînement antérieur) :

• Poids 1 = 2.0 : l'humidité influence fortement la prédiction
• Poids 2 = 1.5 : le soleil aussi, mais un peu moins
• Biais = -1.0 : par défaut, « il fait plutôt froid »

Étape 1 : pré-activation (somme pondérée)

somme = x1*poids1 + x2*poids2 + biais
somme = 0.6*2.0 + 0.8*1.5 + (-1.0)
somme = 1.2 + 1.2 - 1.0
somme = 1.4

À ce stade, somme = 1.4. C'est un nombre brut, sans limites. Il pourrait être 100 ou -50.

Étape 2 : sigmoid (normalisation en probabilité)

La sigmoïde est une courbe lisse en S qui écrase n'importe quel nombre entre 0 et 1.

prediction = sigmoide(1.4)
           = 1 / (1 + e^(-1.4))
           ≈ 0.80

Donc, le neurone dit : 80% de chance que c'est un jour chaud.

Pourquoi la sigmoïde?

En Phase 0, tu as utilisé une règle dure : « Si longueur > 3, c'est Virginica ». C'était un saut sec.

La sigmoïde, c'est le contraire. Au lieu d'un saut, tu obtiens une courbe douce :

• Quand somme est très négatif (-10), sigmoide → 0.00001 (presque 0, mais pas exactement)
• Quand somme = 0, sigmoide → 0.5 (parfaite incertitude)
• Quand somme est très positif (+10), sigmoide → 0.99999 (presque 1)

C'est ce qui permet au neurone de dire « 60% sûr, 80% sûr », au lieu de juste « oui ou non ».

Code Python

Maintenant, le code qui fait ces calculs :

import math

def sigmoide(x):
    # La formule : 1 / (1 + e^(-x))
    # Elle transforme n'importe quel nombre entre 0 et 1
    return 1 / (1 + math.exp(-x))

def neurone(x1, x2, poids1, poids2, biais):
    # Étape 1 : somme pondérée (pré-activation)
    somme = x1 * poids1 + x2 * poids2 + biais
    
    # Étape 2 : appliquer la sigmoïde (activation)
    sortie = sigmoide(somme)
    
    return sortie

# Test avec l'exemple ci-dessus
prediction = neurone(0.6, 0.8, 2.0, 1.5, -1.0)
print(f"Probabilité d'un jour chaud : {prediction:.2f}")  # -> 0.80

# Teste avec des fleurs Iris
# (x1 = longueur pétale, x2 = largeur pétale)
prediction_virginica = neurone(5.1, 1.8, 0.1, 0.1, 0.0)
print(f"C'est une Virginica? {prediction_virginica:.2f} (50% = incertain, proche de 1 = sûr)")

Note sur Python :

• math.exp(x) calcule e^x (la constante e ≈ 2.718, à la puissance x)
• Le point . dans 0.1 indique un nombre décimal (pas un entier)
• :2f dans la chaîne de caractères f"{...:.2f}" veut dire « affiche 2 chiffres après la virgule »

Exercice 2.1 - Ajuster les poids à la main

Tu vas faire maintenant ce que l'apprentissage automatique fait à l'échelle des millions : ajuster les poids pour réduire l'erreur.

La tâche :

Une fleur Virginica a : longueur pétale = 5.1, largeur pétale = 1.8.

Idéalement, le neurone devrait répondre 1.0 (« j'en suis certain, c'est une Virginica »).

Actuellement, avec poids1=0.1, poids2=0.1, biais=0.0, il répond seulement ≈ 0.62.

Ce que tu vas faire :

1. Copie le code du neurone.
2. Teste avec les poids actuels : neurone(5.1, 1.8, 0.1, 0.1, 0.0) → Résultat: 0.62
3. Change UN SEUL poids à la fois, teste, observe.
4. Continue jusqu'à obtenir une réponse > 0.90.

# Voici une solution possible (il y en a d'autres!)
p1, p2, b = 1.2, 0.3, -3.0
resultat = neurone(5.1, 1.8, p1, p2, b)
print(f"Prédiction: {resultat:.3f}")  # -> environ 0.95

# Vérification détaillée (pour comprendre chaque étape)
somme = 5.1*p1 + 1.8*p2 + b
print(f"Somme pré-activation: {somme:.3f}")  # -> environ 5.07
print(f"Après sigmoïde: {resultat:.3f}")  # -> 0.95

Exercice 2.2 - Le défi : classer 4 fleurs à la main

Voilà le vrai défi : trouve UN jeu de poids qui classe correctement toutes les 4 fleurs.

Les données :

Comment le faire :

1. Prépare une boucle qui teste tes poids sur les 4 fleurs à la fois
2. Pour chaque fleur, affiche la prédiction vs l'attendu
3. Ajuste UN poids à la fois
4. Re-teste les 4 fleurs
5. Répète jusqu'à ce que toutes les 4 soient bonnes

Stratégie :

Observe les différences :

• Setosa : x1 ≈ 1.3-1.4 (très court)
• Virginica : x1 ≈ 5.1-5.9 (très long)

La longueur est très différente. La largeur (x2) aussi change, mais moins. Tu peux probablement te débrouiller avec juste poids1 sans poids2.

# Commence ici
p1, p2, b = 0.5, 0.0, -1.0  # Valeurs de départ

# Crée une boucle de test
for nom, x1, x2, attendu in [("A", 1.4, 0.2, 0), 
                               ("B", 1.3, 0.2, 0),
                               ("C", 5.1, 1.8, 1), 
                               ("D", 5.9, 2.1, 1)]:
    pred = neurone(x1, x2, p1, p2, b)
    erreur = "✓" if (pred > 0.5 and attendu == 1) or (pred < 0.5 and attendu == 0) else "✗"
    print(f"{nom}: x1={x1}, x2={x2} | prédiction={pred:.3f} | attendu={attendu} {erreur}")

# Après chaque ajustement, réexécute la boucle

# Une solution qui marche
p1, p2, b = 2.0, 0.0, -3.0

print("TEST FINAL :")
for nom, x1, x2, attendu in [("A", 1.4, 0.2, 0), 
                               ("B", 1.3, 0.2, 0),
                               ("C", 5.1, 1.8, 1), 
                               ("D", 5.9, 2.1, 1)]:
    pred = neurone(x1, x2, p1, p2, b)
    erreur = "✓" if (pred > 0.5 and attendu == 1) or (pred < 0.5 and attendu == 0) else "✗"
    print(f"{nom}: prediction={pred:.3f}, attendu={attendu} {erreur}")

# Calculs détaillés pour fleur C (la plus proche du seuil)
print("\nDétail pour C:")
somme_c = 5.1*p1 + 1.8*p2 + b
print(f"  Somme: 5.1*{p1} + 1.8*{p2} + {b} = {somme_c:.2f}")
pred_c = neurone(5.1, 1.8, p1, p2, b)
print(f"  Sigmoïde({somme_c:.2f}) = {pred_c:.3f}")