Le neurone

Un neurone est une petite machine à décider : il lit des nombres, les pèse, les additionne, puis rend une réponse. Notre fil rouge est un patient dont on a mesuré quatre choses : la température, la fréquence respiratoire, la saturation et l'âge. Ces mesures forment un tenseur (un tableau de nombres) : x = [1,5 ; 2,0 ; −1,8 ; 0,3], de forme 4.

Chaque mesure est multipliée par un poids : un poids positif dit « plus cette mesure est haute, plus je pense à la pneumonie », un poids négatif dit l'inverse. On additionne les produits, puis on ajoute un biais (le point de départ du neurone) : c'est la somme pondérée z.

Le premier neurone du cours a pour poids 0,8 ; 0,5 ; −0,9 ; 0,1 et pour biais −1,0. Pour notre patient :

• 0,8 × 1,5 = 1,2
• 0,5 × 2,0 = 1,0
• −0,9 × (−1,8) = 1,62
• 0,1 × 0,3 = 0,03

Somme : 3,85, moins 1 de biais : z = 2,85. C'est exactement ce que fait (w * x).sum() + b dans PyTorch, sans écrire de boucle. À toi de le faire avec des listes.

x = [1.5, 2.0, -1.8, 0.3]    # température, fréquence respiratoire, saturation, âge
w = [0.8, 0.5, -0.9, 0.1]
b = -1.0

def somme_ponderee(x, w, b):
    produits = [xi * wi for xi, wi in zip(x, w)]
    return ___(produits) + ___

z = somme_ponderee(x, w, b)

La somme pondérée peut valoir n'importe quoi. Une activation la transforme en réponse :

• seuil : 1 si z > 0, sinon 0 (le premier code du cours : z = 2,85 donne 1, z = −0,6 donne 0) ;
• ReLU : remplace un nombre négatif par 0 et laisse passer un nombre positif ;
• sigmoïde : écrase z en un nombre entre 0 et 1, lisible comme une probabilité.

Le deuxième neurone a pour poids −0,3 ; 0,2 ; 0,4 ; −1,1 et pour biais 0,5. Pour le patient : z = −0,45 + 0,4 − 0,72 − 0,33 + 0,5 = −0,6, et la ReLU rend 0 : ce neurone « reste muet » pour ce patient.

Une couche de 3 neurones, ce sont trois sommes pondérées sur les mêmes 4 mesures. On range les poids dans un tableau à 3 lignes (un neurone par ligne) et 4 colonnes (une mesure par colonne) : le produit matriciel W @ x calcule les trois d'un coup. Avec le troisième neurone (poids 0,6 ; −0,4 ; −0,5 ; 0,9, biais −0,2), les trois sorties sont, après ReLU, [2,85 ; 0 ; 1,07].

Un neurone de sortie lit ces trois valeurs (poids 0,9 ; 0,7 ; 0,6, biais −1,5), puis applique la sigmoïde : la probabilité de pneumonie du réseau vaut 0,8464.

x = [1.5, 2.0, -1.8, 0.3]
W = [[0.8, 0.5, -0.9, 0.1], [-0.3, 0.2, 0.4, -1.1], [0.6, -0.4, -0.5, 0.9]]
b = [-1.0, 0.5, -0.2]
w_sortie = [0.9, 0.7, 0.6]
b_sortie = -1.5

def relu(z):
    return max(___, z)

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

def couche(x, W, b):
    return [relu(sum(xi * wi for xi, wi in zip(x, ligne)) + bi) for ligne, bi in zip(W, ___)]

h = couche(x, W, b)
proba = sigmoide(sum(hi * wi for hi, wi in zip(h, w_sortie)) + b_sortie)

PyTorch emballe tout cela dans nn.Linear(4, 3) (une couche de 3 neurones qui lisent 4 nombres : elle calcule W @ x + b) et nn.Sequential, qui enchaîne les couches. Le réseau du patient s'écrit : Linear(4, 3), ReLU, Linear(3, 1), Sigmoid. Au départ, PyTorch tire les poids au hasard ; le but des parties suivantes est de les apprendre.

Chaque neurone a un poids par entrée plus un biais : la première couche en compte 3 × 4 + 3 = 15, la seconde 3 × 1 + 1 = 4. Au total : 19 paramètres.

def parametres(entrees, neurones):
    # poids + biais
    return entrees * neurones + ___

total = parametres(4, 3) + parametres(___, 1)