Partie 2 · Apprendre

La perte et ses pentes

Un neurone aux poids tirés au hasard se trompe. Pour l'améliorer, il faut d'abord mesurer à quel point il se trompe : c'est la perte. Pour une réponse oui/non, la probabilité de la bonne réponse est a pour un patient malade (y = 1) et 1 − a pour un patient sain (y = 0). La perte vaut −log de cette probabilité, moyennée sur les patients.

Pourquoi le logarithme ? Une bonne réponse sûre (p proche de 1) coûte presque 0 ; une mauvaise réponse sûre (p proche de 0) coûte énormément.

La perte −log(p) selon la probabilité p de la bonne réponse. Les deux boutons donnent les deux valeurs de départ du cours : 0,6931 (p = 0,5) et 2,3979 (11 organes équiprobables, p = 1/11).

Six patients, un seul nombre : t = température − 38 °C = [1,5 ; 1,0 ; −0,5 ; −1,5 ; −1,0 ; 0,5], avec y = [1, 1, 1, 0, 0, 0] (1 = pneumonie). Le neurone calcule z = w × t + b puis a = sigmoïde(z). Au départ w = 0 et b = 0 : les six probabilités valent 0,5, et la perte vaut 0,6931 (= −log 0,5).

À toi de coder

La perte des six patients

Tu vas calculer toi-même la perte du neurone pour un couple (w, b), comme le fait PyTorch. Le point qui piège : pour un patient sain (y = 0), la probabilité de la bonne réponse n'est pas a mais 1 − a. Si tu prends toujours a, un patient sain bien reconnu serait compté comme une erreur.

Complète perte(w, b) : probabilité de la bonne réponse de chaque patient, puis moyenne des −log. Tu dois retrouver 0,6931 en (0 ; 0) et 0,4963 en (1 ; 0).

t = [1.5, 1.0, -0.5, -1.5, -1.0, 0.5]   # température - 38 °C
y = [1, 1, 1, 0, 0, 0]                  # 1 = pneumonie

def sigmoide(z):
    return 1 / (1 + math.exp(-z))

def perte(w, b):
    total = 0
    for ti, yi in zip(t, y):
        a = sigmoide(w * ti + b)
        p = a if yi == 1 else ___
        total += -math.log(p)
    return total / ___

Ctrl/⌘+Entrée

Maintenant la question centrale : dans quel sens changer w pour que la perte baisse ? La réponse est la pente de la courbe « perte selon w ». En w = 0 la pente vaut −0,3333 : négative, donc augmenter w fait baisser la perte. La pente de b vaut 0 : avec autant de malades que de bien portants, répondre 0,5 à tout le monde est déjà le meilleur choix pour b.

PyTorch trouve ces pentes tout seul : perte.backward() les range dans w.grad et b.grad (c'est la rétropropagation). En w = 1, on trouve perte = 0,4963 et pente = −0,0771 : plus petite, car on se rapproche du creux (w ≈ 1,46) et la courbe s'aplatit.

La perte des six patients selon w (b = 0), avec la tangente au point choisi. Teste w = 0 (pente −0,3333), w = 1 (pente −0,0771), puis cherche le creux autour de 1,46.

À toi de coder

Mesurer une pente sans formule

Une pente, c'est « de combien la perte bouge quand w bouge un tout petit peu ». Tu peux donc la mesurer sans connaître aucune formule : compare la perte un peu à droite et un peu à gauche de w, et divise par l'écart (différence centrée). C'est une approximation de ce que calcule backward() ; elle est utile pour vérifier une rétropropagation.

La fonction perte(w, b) est déjà écrite (c'est celle de l'exercice précédent). Complète pente_w(w, b, e=1e-4) : tu dois retrouver −0,3333 en w = 0 et −0,0771 en w = 1.

t = [1.5, 1.0, -0.5, -1.5, -1.0, 0.5]
y = [1, 1, 1, 0, 0, 0]

def perte(w, b):
    s = 0
    for ti, yi in zip(t, y):
        a = 1 / (1 + math.exp(-(w * ti + b)))
        s += -math.log(a if yi == 1 else 1 - a)
    return s / len(t)

def pente_w(w, b, e=1e-4):
    return (perte(w + e, b) - perte(___, b)) / (___ * e)

Ctrl/⌘+Entrée

Pour plusieurs réponses (les 11 organes, partie 5), le réseau rend un score par organe et la softmax les transforme en probabilités qui somment à 1. Pour la coupe de la partie 4 avec les scores foie, rate, rein = [2,0 ; 1,0 ; 0,1] : probabilités [0,6590 ; 0,2424 ; 0,0986]. La bonne réponse est le foie : perte = −log(0,6590) = 0,4170.

Un réseau qui n'a encore rien appris donne le même score aux 11 organes : p = 1/11 et perte = −log(1/11) = 2,3979 (≈ 2,40). Retiens ce nombre : au démarrage d'un entraînement, la perte doit être proche de lui. nn.CrossEntropyLoss calcule tout cela, mais elle reçoit les scores bruts (elle applique la softmax elle-même), pas les probabilités.

À toi de coder

Softmax et perte à plusieurs réponses

La softmax met chaque score à l'exponentielle puis divise par la somme des exponentielles : ainsi les probabilités sont positives et totalisent 1. Si tu oublies de diviser par la somme, tu obtiens des nombres sans signification (plus grands que 1). La perte est ensuite le −log de la probabilité de la bonne classe seulement.

Complète softmax(scores) et perte_classe(scores, bonne) (bonne = numéro de la bonne case). Tu dois retrouver 0,4170 pour le foie et 2,3979 pour 11 scores nuls.

def softmax(scores):
    exps = [math.exp(s) for s in scores]
    total = sum(___)
    return [e / total for e in exps]

def perte_classe(scores, bonne):
    return -math.log(softmax(scores)[___])

Ctrl/⌘+Entrée