Partie 1 · Créer

Compresser puis reconstruire

Hier le modèle de langage prolongeait un texte. Aujourd'hui on veut la même chose pour des images : fabriquer des coupes de scanner qui n'existent pas, pour partager des données sans partager les images de vrais patients (le besoin du CHU).

Première idée naïve : une coupe d'OrganAMNIST fait 28 × 28 pixels, soit 784 nombres entre 0 (noir) et 1 (blanc). Tirons-les au hasard ? On obtient du bruit, et pratiquement jamais une coupe. Dans une vraie coupe, deux pixels voisins ont des valeurs proches : les 784 nombres dépendent les uns des autres. On devrait donc pouvoir les résumer en beaucoup moins de nombres.

Plus le goulot (le code) est étroit, plus la reconstruction perd de détails. Le vrai réseau n'utilise pas des blocs : il apprend ce qui compte.

Un autoencodeur est un réseau qui reçoit une image et rend une image de même taille. L'encodeur (un MLP de J1, 784 → 128 → 2) résume l'image en un vecteur court, son code. Le décodeur (2 → 128 → 784) reconstruit l'image à partir du code. Ici le code a 2 composantes : l'ensemble des codes possibles s'appelle l'espace latent, c'est le plan, et chaque image y devient un point.

Le réseau a 202 258 poids. Vérifie ce chiffre toi-même.

À toi de coder

Compter les poids de l'autoencodeur

Une couche dense a un poids par paire (entrée, sortie) plus un biais par sortie : on oublie souvent ce second terme. L'autoencodeur du cours enchaîne quatre couches : 784 → 128, 128 → 2, 2 → 128, 128 → 784. Écris couche(entrees, sorties), puis additionne les quatre dans total. Tu dois retrouver le 202 258 de la slide, ce qui prouve que tu as bien compris l'architecture.

def couche(entrees, sorties):
    # poids + biais
    return entrees * sorties + ___

total = couche(784, 128) + couche(128, 2) + couche(2, 128) + couche(128, 784)

Ctrl/⌘+Entrée

Aucune étiquette n'est nécessaire : l'image est à la fois l'entrée et la bonne réponse. La perte est la MSE de J1 entre l'image et sa reconstruction. Exemple réduit de la slide (2 pixels, code d'un seul nombre, poids choisis) : l'image [0,9 ; 0,7].

Coder : l'encodeur fait la moyenne des deux pixels, 0,5 × 0,9 + 0,5 × 0,7 = 0,8.
Reconstruire : le décodeur recopie le code dans chaque pixel, [0,8 ; 0,8].
Comparer : ((0,9 − 0,8)² + (0,7 − 0,8)²) / 2 = 0,01.

À toi de coder

Coder, reconstruire, comparer

Tu codes à la main le mini-autoencodeur ci-dessus. Trois pièces, dans l'ordre où le réseau les utilise : coder (moyenne des 2 pixels), decoder (recopie le code dans chaque pixel), mse (écart moyen au carré). Le « moyenne » de la MSE est important : il faut diviser par le nombre de pixels, sinon la perte grandit avec la taille de l'image et on ne peut plus comparer deux images de tailles différentes.

Puis erreur(image) enchaîne les trois : c'est l'erreur de reconstruction de l'image.

def coder(image):
    return ___ * image[0] + ___ * image[1]

def decoder(code):
    return [code, ___]

def mse(a, b):
    return sum((x - y) ** 2 for x, y in zip(a, b)) / ___

def erreur(image):
    return mse(image, decoder(coder(image)))

Ctrl/⌘+Entrée

Une image inhabituelle se reconstruit mal. Le même réseau code [0,9 ; 0,1] par 0,5 et la reconstruit en [0,5 ; 0,5] : perte 0,16, soit 16 fois plus que pour [0,9 ; 0,7]. Le réseau n'a appris à résumer que ce qu'il a vu (des images où les voisins se ressemblent).

On en tire un détecteur d'anomalies : on entraîne l'autoencodeur sur des images normales seulement, et l'erreur de reconstruction d'une nouvelle image devient un score d'anomalie. Au-dessus d'un seuil choisi sur la validation (comme en J2), on signale l'image.

Bouge les deux pixels et le seuil. Une image dont les pixels voisins diffèrent beaucoup dépasse le seuil.

Limites à garder en tête (exercice 3, radiographies de PneumoniaMNIST) : le score dit qu'une image est inhabituelle, pas pourquoi. Une image mal cadrée sera signalée, elle aussi. Et rien ne garantit que les pneumonies aient une plus grande erreur que les normales : à mesurer. Le protocole : autoencodeur à code de 16 composantes entraîné sur les normales, seuil = quantile 0,95 des scores des normales de validation (5 % de fausses alertes acceptées), puis mesure une seule fois sur le test : sensibilité (part des pneumonies signalées) et spécificité (part des normales non signalées).

À toi de coder

Seuil, sensibilité, spécificité

Tu rejoues le protocole de l'exercice 3 avec des scores choisis (scores_normales, 20 normales de validation). Le seuil laisse 95 % des normales en dessous : on trie les scores et on prend celui d'indice int(0.95 * n) - 1. Ce choix est fait sur la validation pour ne pas régler le seuil sur le test.

Puis, sur le test : sensibilite = part des pneumonies au-dessus du seuil (bien signalées) ; specificite = part des normales au plus égal au seuil (non signalées à tort). Les deux sont des fractions entre 0 et 1.

scores_normales = [0.010, 0.012, 0.009, 0.015, 0.011, 0.013, 0.010, 0.014, 0.012, 0.016,
                  0.011, 0.013, 0.009, 0.012, 0.014, 0.010, 0.015, 0.011, 0.017, 0.030]
normales_test = [0.011, 0.016, 0.019, 0.012]
pneumo_test = [0.014, 0.025, 0.040, 0.018, 0.031]

n = len(scores_normales)
seuil = sorted(scores_normales)[int(0.95 * n) - ___]
sensibilite = sum(1 for s in pneumo_test if s ___ seuil) / len(pneumo_test)
specificite = sum(1 for s in normales_test if s ___ seuil) / len(normales_test)

Ctrl/⌘+Entrée

Pourquoi ne peut-on pas encore générer ? Voici les codes de 2 000 coupes de validation, une couleur par organe : ils forment des nuages séparés par des zones vides, où ne tombe le code d'aucune coupe. Un code tiré dans une zone vide n'a jamais servi à l'entraînement : rien ne garantit que le décodeur en fasse une coupe plausible. Pour générer, il faudrait savoir où tirer un code. C'est le problème de la partie 2.