Phase 08: Generative AI

Les flux correspondants et les flux corrigés

Type: Build

Languages: Python

Prerequisites: Phase 8 · 06 (DDPM), Phase 1 · Calculus

Time: ~45 minutes

Le problème

Le processus inverse du DDPM est une marche stochastique de 1000 pas de N(0, I)Le blocage est que le processus inverse est rigide, le chemin est incurvé.

Si vous pouviez former le modèle de telle sorte que le chemin du bruit vers les données était une ligne droite, un seul pas d'Euler de t=1à t=0Le flux de correspondance construit ceci directement: définir une interpolation en ligne droite à partir dex_1 ∼ N(0, I)à x_0 ∼ data, entraîne un champ vectoriel v_θ(x, t)pour correspondre à sa dérivée temporelle, intégrer à l'inférence.

Le flux rectifié (Liu 2022) va plus loin: redresser de manière itérative les chemins avec une procédure de reflux qui produit un ODE progressivement plus proche de la ligne. Après deux itérations de reflux, un échantillonneur en 2 étapes correspond à la qualité DDPM en 50 étapes.

Le concept

!Flow matching: straight-line interpolation between noise and data

Flux en ligne droite

Définir:

Copyx_t = t · x_1 + (1 - t) · x_0,   t ∈ [0, 1]

où x_0 ~ dataet x_1 ~ N(0, I)La dérivée temporelle le long de cette ligne droite est constante:

Copydx_t / dt = x_1 - x_0

Définir un champ vectoriel neuronal v_θ(x_t, t)et l'entraîner à correspondre à cette dérivé:

CopyL = E_{x_0, x_1, t} || v_θ(x_t, t) - (x_1 - x_0) ||²

C' est le conditional flow matchingL'apprentissage est sans simulation: vous ne déployez jamais l'ODE.(x_0, x_1, t)et le régression.

Prise d'échantillons

Pour l'inférence, intégrez le champ vectoriel appris à l'arrière dans le temps:

Copyx_{t-Δt} = x_t - Δt · v_θ(x_t, t)

Commencez par x_1 ~ N(0, I), Euler-passer vers le bas à t=0- Je suis désolé .

Flux rectifié (Liu 2022)

Les voies de la ligne droite fonctionnent, mais les voies apprises ne sont pas en fait droites. Elles se courbent parce que beaucoup de voies sont droites.x_0s peut être cartographié à la même x_1. étape de reflux du flux rectifié:

1. Modèle de débit de train v_1 avec des couplages aléatoires.
2. Pratique N paires (x_1, x_0)en intégrant v_1 à partir de x_1à son atterrissage x_0- Je suis désolé .
3. En train de v_2 sur ces exemples en couple. Parce que les paires sont maintenant "ODE-matched", l'interpolant en ligne droite entre eux est vraiment plus plat.
4. Je répète.

En pratique, 2 itérations de reflux vous amènent à une approche linéaire, permettant une inférence de 2 à 4 étapes. SDXL-Turbo, SD3-Turbo, LCM sont tous des modèles distillés à partir de flux.

Pourquoi cette image a gagné en 2024 ?

Trois raisons:

1. Simulation-free training aucune ODE déroulant pendant la formation, trivial à mettre en œuvre.
2. Better loss geometry les voies droites ont une signal-au-bruit cohérente, alors que la DDPM ε-loss a une mauvaise SNR aux bords du calendrier.
3. Faster inference 4 à 8 étapes à la qualité SDXL-Turbo; 1 étape avec distillation de consistance.

Parallèle de flux par rapport à DDPM connexion exacte

Le flux correspondant à un chemin conditionné de Gauss est la diffusion avec un calendrier de bruit spécifique.x_t = α(t) x_0 + σ(t) x_1Le calendrier et le flux correspondant récupèrent la diffusion réformée par Stratonovich avec v = α'·x_0 - σ'·x_1Les deux sont équivalents algébriques pour les chemins gaussiens.

Ce que l'ajustement de flux a ajouté: la clarté de la cible (une vitesse simple), une perte plus nette et la licence d'expérimenter avec des interpolants non gaussiens.

Faites-le

code/main.pyIl met en œuvre une correspondance de flux 1D sur un mélange gaussien à deux modes.v_θ(x, t)En conclusion, intégrez les étapes 1, 2, 4 et 20 d'Euler et comparez la qualité de l'échantillon.

Étape 1: Perte de formation

pythonCopydef train_step(x0, net, rng, lr):
    x1 = rng.gauss(0, 1)
    t = rng.random()
    x_t = t * x1 + (1 - t) * x0
    target = x1 - x0
    pred = net_forward(x_t, t)
    loss = (pred - target) ** 2
    # backprop + update

Étape 2: inférence en plusieurs étapes

pythonCopydef sample(net, num_steps):
    x = rng.gauss(0, 1)
    for i in range(num_steps):
        t = 1.0 - i / num_steps
        dt = 1.0 / num_steps
        x -= dt * net_forward(x, t)
    return x

Étape 3: comparer le nombre d'étapes

Attendez-vous que le prélèvement de 4 étapes corresponde déjà à la qualité de 20 étapes un gros problème pour la latence.

Les pièges

• Time parameterization.Utilisation de l' échange de flux t ∈ [0, 1]avec t=0à la base de données, t=1à l'aide de la DDPMt ∈ [0, T]avec t=0à la base de données, t=TLes journaux se trompent constamment.
• Schedule choice.La ligne droite du flux rectifié est le calendrier de correspondance des flux, mais vous pouvez utiliser l'échantillonnage t-normal cosine ou logite (SD3 le fait) pour une meilleure couverture à l'échelle.
• Reflow cost.Générer le jeu de données en couple pour le reflux est un passage d'inférence complet par échantillon.
• Classifier-free guidance still applies.Il suffit d' échanger ε contre v dans la combinaison linéaire: v_cfg = (1+w) v_cond - w v_uncond- Je suis désolé .

Utilisez-le

Chaque fois qu'un article dit "plus vite que la diffusion" en 2025-2026, c'est presque toujours le flux correspondant + la distillation.

La faire partir

• Ça va .outputs/skill-fm-tuner.md. Skill prend une spécification de modèle de diffusion et la convertit en une configuration de formation correspondant au flux: choix de calendrier, répartition des échantillons de temps (uniforme / logit-normal), optimisateur, plan de reflux, compte de étapes cibles, protocole d'évaluation.

Exercices

1. Easy.On court .code/main.pyet comparer la MSE de 1 étape contre 20 étapes contre la réelle distribution des données.
2. Medium.Passez de l' uniforme .tL'échantillonnage est-il en phase logit-normale (concentre l'échantillonnage au milieu de la phase t)?
3. Hard.Implémenter une itération de reflux: générer des paires (x_0, x_1) en intégrant le premier modèle, entraîner un deuxième modèle sur les paires et comparer la qualité de l'échantillon en 1 étape.

Les termes clés

Note de production: Flux.1-schnell est le flux correspondant à son plus rapide

Le résultat de la production de flux matching est Flux.1-schnell un flux-matched DiT distillé à 1-4 étapes d'inférence tout en maintenant la qualité de flux-dev-grade. Le bloc-notes de Niels "Run Flux sur une machine de 8 Go" est la recette de déploiement de référence: T5 + CLIP code, quantifié MMDiT dénoncer (en 4 étapes pour rapide vs 50 pour dev), VAE décode. La comptabilité des coûts:

La règle de production: flow-matched base + distillation = the 2026 default for fast text-to-image.Chaque grand fournisseur expédie cette combinaison: SD3-Turbo (SD3 + flux + distillation), Flux-schnell (Flux-dev + rectifié-flux), CogView-4-Flash.

Pour en savoir plus

• Liu, Gong, Liu (2022). Flow Straight and Fast: Learning to Generate and Transfer Data with Rectified Flow débit rectifié.
• Lipman et al. (2023). Flow Matching for Generative Modeling correspondance des flux.
• Esser et al. (2024). Scaling Rectified Flow Transformers for High-Resolution Image Synthesis SD3, débit rectifié à l'échelle.
• Albergo, Vanden-Eijnden (2023). Stochastic Interpolants cadre général qui couvre la diffusion FM+.
• Song et al. (2023). Consistency Models Destilation en 1 étape de diffusion/flux.
• Sauer et al. (2023). Adversarial Diffusion Distillation (SDXL-Turbo) Variante turbo.
• Black Forest Labs (2024). Flux.1 models correspondance des flux dans la production.

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.