Partie 3 · Créer

Deux autres façons de générer

Deux familles font des images plus nettes que le VAE. D'abord le GAN (Goodfellow et al., 2014), qui entraîne deux réseaux l'un contre l'autre :

Fabriquer : le générateur reçoit un vecteur de 64 nombres tiré au hasard (comme le code z du VAE, qui n'en a que 2) et rend une image.
Juger : le discriminateur, un classifieur de J1 avec une sigmoïde, reçoit une image et rend la probabilité qu'elle soit vraie.
Alterner : un pas pour le discriminateur (séparer vraies et fausses), puis un pas pour le générateur (le tromper).

Pousse p : ce qui réjouit le générateur (perte faible) est exactement ce qui gêne le discriminateur.

La perte du générateur est − ln de la probabilité « vraie » donnée à son image : 1,61 pour p = 0,2, puis 0,92 pour p = 0,4. Elle baisse quand le générateur se rapproche de la vérité. Le discriminateur, lui, veut p petit sur les fausses et grand sur les vraies.

Quand s'arrêter ? Aucune des deux pertes ne le dit, puisque chacune dépend de l'autre réseau : on s'arrête après un nombre d'époques fixé, en regardant les images. C'est sa limite, avec un entraînement instable et le risque de ne produire qu'un type d'image.

À toi de coder

Les pertes du générateur et du discriminateur

Le générateur veut que le discriminateur donne une probabilité « vraie » haute à sa fausse image. Un logarithme négatif transforme cela en perte : − ln(p) est grand quand p est proche de 0 (le générateur est démasqué) et nul quand p = 1. Écris perte_generateur(p).

Le discriminateur, lui, a deux objectifs : une probabilité haute p_vrai sur la vraie image, basse p_faux sur la fausse, d'où perte_discriminateur = −ln(p_vrai) − ln(1 − p_faux). Attention au « 1 − » : sans lui, le discriminateur serait récompensé de croire les fausses images vraies.

def perte_generateur(p):
    return -math.log(___)

def perte_discriminateur(p_vrai, p_faux):
    return -math.log(p_vrai) - math.log(1 - ___)

Ctrl/⌘+Entrée

Seconde famille : la diffusion (Ho, Jain et Abbeel, 2020) génère en retirant du bruit.

Abîmer : on mélange l'image à un bruit tiré au hasard, par un calcul exact, sans réseau.
Apprendre : un réseau reçoit l'image abîmée et le numéro de l'étape, et prédit le bruit ajouté. La perte est la MSE de J1 entre sa prédiction et le vrai bruit.
Générer : on part d'un bruit pur et on retire une partie du bruit prédit, puis on recommence, de l'étape 200 à l'étape 1. Le réseau sert donc 200 fois pour une image (1 000 dans l'article d'origine).

La formule (complément, slide 44).

x(t) = √ᾱ(t) × x(0) + √(1 − ᾱ(t)) × ε

x(0) est l'image, ε un bruit de loi normale centrée réduite, t le numéro de l'étape, ᾱ(t) un nombre fixé à l'avance qui descend de presque 1 à presque 0 quand t va de 1 à T. Exemple : ᾱ(t) = 0,81, donc √ᾱ = 0,9 et √(1 − ᾱ) ≈ 0,44 ; l'image [0,9 ; 0,7] et le bruit [0,5 ; −1] donnent [1,03 ; 0,19].

Génération : de t = T à t = 1, on retire de x(t) une fraction du bruit prédit, on divise pour remettre l'image à l'échelle, et on ajoute un petit bruit neuf, sauf à la dernière étape.

Fais glisser t : au début l'image, à la fin du bruit. La formule ne dépend d'aucun réseau.

À toi de coder

Abîmer une image, puis la perte du réseau

Tu écris le calcul exact d'abîmage, composante par composante : l'image pèse racine(ᾱ), le bruit pèse racine(1 − ᾱ). Deux cas limites te guident : ᾱ = 1 donne l'image intacte, ᾱ = 0 du bruit pur. Le bruit ε est fourni.

Ensuite la perte d'entraînement : le réseau prédit le bruit, on compare à ε par la MSE (moyenne des carrés des écarts). Avec la prédiction [0,4 ; −0,8] au lieu de [0,5 ; −1], calcule perte.

def abimer(x0, eps, abar):
    return [math.sqrt(abar) * x + math.sqrt(___ - abar) * e for x, e in zip(x0, eps)]

image = [0.9, 0.7]
bruit = [0.5, -1]
x_t = abimer(image, bruit, 0.81)

prediction = [0.4, -0.8]
perte = sum((p - e) ** 2 for p, e in zip(prediction, bruit)) / ___

Ctrl/⌘+Entrée

Trois familles, trois compromis. Les trois transforment un vecteur tiré au hasard en image. Le VAE est rapide (1 passage du décodeur) mais flou ; le GAN est net (1 passage du générateur) mais instable ; la diffusion est la plus nette et stable (une MSE qui baisse), mais lente : de une centaine à 1 000 passages par image. Les générateurs actuels comme Stable Diffusion (Rombach et al., 2022) sont des modèles de diffusion : lents, mais les plus nets, et guidés par un texte.

Coche tes priorités : la famille qui cumule le plus d'avantages est mise en gras.

À quoi ça sert, et ce qu'il faut surveiller. En santé : fabriquer des images synthétiques pour partager des données sans sortir les images de patients, ou ajouter des exemples d'une classe rare ; repérer des images inhabituelles par l'erreur de reconstruction (partie 1). Risques : la mémorisation (un modèle peut recopier presque à l'identique des images d'entraînement : une image synthétique n'est pas anonyme par principe, il faut le vérifier, Carlini et al., 2023) ; les biais (il reproduit les déséquilibres de ses données) ; l'usage frauduleux (images ou voix crédibles de personnes réelles).