Czym są modele dyfuzyjne? Jak działają i czym różnią się od LLM

Gdy ChatGPT pisze tekst, a Stable Diffusion rysuje obraz, oba narzędzia wydają się robić to samo: tworzyć coś z opisu. Pod spodem działają jednak zupełnie inne mechanizmy. Duże modele językowe układają odpowiedź słowo po słowie, a modele dyfuzyjne zaczynają od szumu i przez wiele kroków wyłaniają z niego obraz. Warto rozumieć tę różnicę, bo wyznacza ona, do czego który model się nadaje i dlaczego granica między nimi powoli się zaciera.

Czym są modele dyfuzyjne?

Model dyfuzyjny (diffusion model) to rodzaj modelu generatywnego, czyli takiego, który uczy się produkować nowe dane podobne do tych, na których się uczył. Jedną z kluczowych prac była publikacja Jonathana Ho, Ajaya Jaina i Pietera Abbeela z 2020 roku („Denoising Diffusion Probabilistic Models”), w której autorzy pokazali, że takie modele potrafią generować obrazy wysokiej jakości. Nazwa „dyfuzja” bierze się z analogii do fizyki: autorzy inspirowali się procesami z termodynamiki nierównowagowej, w których uporządkowany układ stopniowo się rozprasza.

Idea jest prosta: jeśli potrafisz nauczyć model odróżniać obraz od szumu i krok po kroku ten szum usuwać, to zaczynając od losowego szumu możesz „odszumić” go do zupełnie nowego obrazu.

Jak działa model dyfuzyjny krok po kroku?

Cały mechanizm da się opisać w trzech krokach:

1. Proces w przód (zaszumianie). Bierzesz prawdziwy obraz i przez wiele małych kroków dodajesz do niego szum, aż zostanie niemal czysty szum. Ten etap nie wymaga uczenia, to ustalony wzór.
2. Uczenie. Pokazujesz modelowi obraz w pewnym stopniu zaszumiony i każesz mu przewidzieć, jaki szum został dodany. Model uczy się na ogromnej liczbie takich par.
3. Generowanie (proces wstecz). Startujesz od czystego, losowego szumu i w wielu krokach usuwasz z niego szum, który model przewiduje. Każdy krok wyłania więcej struktury, aż powstaje nowy obraz.

Poniżej mała symulacja na ośmiu „pikselach”, bez bibliotek. Nie jest to prawdziwy model dyfuzyjny, bo nic się tu nie uczy, ale pokazuje trzy rzeczy: jak szum zjada oryginał, że z idealnie znanym szumem oryginał można odtworzyć i że jakość wyniku zależy od trafności prognozy szumu:

import math
import random

random.seed(7)

# "Obraz": 8 wartości, np. jasność ośmiu pikseli
x0 = [1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0]
STEPS = 20
betas = [0.02 + 0.28 * i / (STEPS - 1) for i in range(STEPS)]  # ile szumu dodajemy w kroku

# alpha_bar[t]: jaka część oryginalnego sygnału zostaje po t+1 krokach
alpha_bar = []
product = 1.0
for beta in betas:
    product *= 1 - beta
    alpha_bar.append(product)


def noisy(x, t, eps):
    # Proces w przód: x_t = sqrt(ab) * x0 + sqrt(1 - ab) * szum
    return [math.sqrt(alpha_bar[t]) * v + math.sqrt(1 - alpha_bar[t]) * e for v, e in zip(x, eps)]


def denoise(xt, t, eps_pred):
    # Odwrócenie wzoru: z zaszumionego obrazu i prognozy szumu odtwarzamy obraz
    return [(x - math.sqrt(1 - alpha_bar[t]) * e) / math.sqrt(alpha_bar[t]) for x, e in zip(xt, eps_pred)]


def mean_error(a, b):
    return sum(abs(x - y) for x, y in zip(a, b)) / len(a)


eps = [random.gauss(0, 1) for _ in x0]
for t in (0, 9, 19):
    print(f"krok {t + 1:2d}: z oryginału zostaje {alpha_bar[t]:.0%}")

t = 19
xt = noisy(x0, t, eps)
print("błąd odtworzenia z idealną prognozą szumu:", round(mean_error(x0, denoise(xt, t, eps)), 2))
print("błąd odtworzenia, gdy model zgaduje brak szumu:", round(mean_error(x0, denoise(xt, t, [0.0] * len(x0))), 2))

Wynik uruchomienia: współczynnik zachowanego oryginału spada z 98% w pierwszym kroku do 40% w dziesiątym i 3% w dwudziestym, czyli po 20 krokach z obrazu zostaje prawie sam szum. Gdy znamy szum dokładnie, odtworzenie jest bezbłędne (błąd 0,0). Gdy „model” zgaduje, że szumu nie ma, błąd rośnie do 2,96. Cała sztuka prawdziwych modeli dyfuzyjnych polega na tym, że sieć neuronowa uczy się przewidywać ten szum możliwie dokładnie, a generowanie to odejmowanie przewidzianego szumu w wielu kolejnych krokach.

Dlaczego ten sam opis daje za każdym razem inny obraz?

Generowanie zaczyna się od losowego szumu, a ten wyznacza ziarno losowania (seed). Widać to w symulacji: ten sam kod z ziarnem 1 daje za każdym razem identyczny szum startowy, a z ziarnem 2 zupełnie inny.

import random


def start_noise(seed: int, size: int = 4):
    rng = random.Random(seed)
    return [round(rng.gauss(0, 1), 2) for _ in range(size)]


print("ziarno 1:", start_noise(1))
print("ziarno 1 (drugi raz):", start_noise(1))
print("ziarno 2:", start_noise(2))

Po uruchomieniu: ziarno 1 daje [1.29, 1.45, 0.07, -0.76] i przy drugim wywołaniu dokładnie to samo, a ziarno 2 daje [2.34, -0.66, 0.39, 0.15]. W prawdziwych narzędziach działa to analogicznie: przy tym samym modelu i ustawieniach stałe ziarno pozwala powtórzyć wynik, a zmiana ziarna daje wariant tego samego opisu. Dlatego przy eksperymentach warto zapisywać ziarno razem z opisem.

Skąd model wie, co ma narysować?

Sam proces odszumiania dałby losowy obraz. Żeby model rysował to, o co prosisz, trzeba go warunkować, czyli podać mu dodatkową informację, na przykład opis tekstowy. Praca o latent diffusion (Rombach i współautorzy, 2022) opisuje to jako dodanie do sieci warstw uwagi krzyżowej (cross-attention), dzięki którym model przy każdym kroku odszumiania „patrzy” na zakodowany opis i dopasowuje do niego to, co rysuje. W ten sposób ten sam mechanizm można warunkować nie tylko tekstem, ale też np. ramkami ograniczającymi (bounding boxes).

Dlaczego Stable Diffusion działa w „przestrzeni ukrytej”?

Odszumianie obrazu piksel po pikselu jest bardzo kosztowne. Według autorów pracy o latent diffusion trening modeli dyfuzyjnych działających bezpośrednio na pikselach potrafi pochłaniać setki dni pracy kart graficznych, a samo generowanie wymaga wielu sekwencyjnych obliczeń. Ich pomysł: najpierw skompresować obraz wytrenowanym autoenkoderem do znacznie mniejszej reprezentacji (przestrzeni ukrytej, latent space), a dyfuzję prowadzić na niej, nie na pikselach. Dopiero na końcu dekoder zamienia wynik z powrotem w obraz. To znacząco obniża wymagania obliczeniowe i dlatego tego podejścia używa Stable Diffusion; Sora też pracuje na kodach latentnych wideo, nie na pikselach.

Z czego zbudowana jest sieć w modelu dyfuzyjnym?

Przez lata sercem takich modeli była sieć typu U-Net (zbudowana z warstw konwolucyjnych). W 2022 roku William Peebles i Saining Xie pokazali w pracy „Scalable Diffusion Models with Transformers”, że można ją zastąpić transformerem pracującym na łatach (patches) przestrzeni ukrytej. Ich największy model, DiT-XL/2, osiągnął na zbiorze ImageNet 256×256 wynik FID 2,27 (im niższy, tym lepiej), a autorzy wykazali, że więcej obliczeń prowadzi do lepszej jakości. Ten kierunek wykorzystał m.in. OpenAI przy modelu Sora: według raportu to tekstowo warunkowy model dyfuzyjny z transformerem działającym na łatach czasoprzestrzennych obrazów i wideo.

Zwróć uwagę na ciekawy skutek: transformer, czyli ta sama rodzina architektur, na której stoją duże modele językowe, pracuje też w modelach dyfuzyjnych. Różnica nie leży więc w „silniku”, tylko w tym, jak model generuje wynik.

Do czego służą modele dyfuzyjne?

AlphaFold 3 to dobry przykład, że dyfuzja nie ogranicza się do grafiki. Komentatorzy zwracają jednak uwagę, że moduł dyfuzyjny potrafi wygenerować wiarygodnie wyglądające, a błędne struktury, więc ważne są miary pewności. To ta sama lekcja, którą znamy z halucynacji LLM: dobry wygląd wyniku nie jest dowodem jego poprawności.

Czym modele dyfuzyjne różnią się od LLM?

W praktyce najważniejsze rozróżnienie jest takie: LLM zamienia tekst w tekst token po tokenie, więc dobrze radzi sobie z rozumowaniem krok po kroku i rozmową, a model dyfuzyjny zamienia opis w obraz lub wideo przez odszumianie, więc dobrze oddaje szczegóły wizualne. Dla czytelnika znającego artykuł Czym jest LLM kluczowa różnica brzmi: LLM losuje następny token z rozkładu prawdopodobieństwa, a model dyfuzyjny odejmuje przewidziany szum od całej próbki.

Czy istnieją dyfuzyjne modele językowe?

Tak. W 2025 roku grupa badaczy opublikowała LLaDA, model językowy trenowany od zera metodą dyfuzji. Zamiast szumu stosuje się tam maskowanie tokenów: proces w przód losowo zasłania część tekstu, a transformer uczy się odgadywać zasłonięte tokeny, i generowanie polega na stopniowym odsłanianiu tekstu. Autorzy twierdzą, że ich model z 8 mld parametrów jest po douczeniu konkurencyjny wobec LLaMA 3 8B w zadaniach uczenia w kontekście i porównywalny z własnymi bazowymi modelami autoregresyjnymi w testach ogólnych, matematycznych i programistycznych.

Podobnym kierunkiem zajmują się komercyjne projekty, jak Mercury (Inception Labs) czy Gemini Diffusion (Google). Producenci deklarują, że takie modele potrafią generować tekst szybciej niż klasyczne LLM, bo wiele tokenów powstaje równolegle, ale są to deklaracje z różnych sprzętów i zadań, których nie da się bezpośrednio porównać. Według opisów jest też kompromis: pierwszy fragment tekstu pojawia się dopiero po całej serii kroków, a nie od razu jak w strumieniu z klasycznego LLM. Traktuj to jako obiecujący kierunek, a nie jako utrwalony standard.

Jakie są ograniczenia modeli dyfuzyjnych?

Ślad energetyczny i wodny dużych modeli generatywnych opisujemy w sekcji o kosztach w artykule Czym jest LLM.

Które zadanie w aplikacji powierzyć LLM, a które modelowi dyfuzyjnemu?

Wniosek z różnic opisanych wyżej da się zamienić w prostą regułę: patrz na to, co ma być wynikiem.

W wielu produktach oba modele współpracują: LLM pomaga przygotować dobry opis, a model dyfuzyjny rysuje według niego.

Jak zacząć pracę z modelami dyfuzyjnymi jako programista?

Najprostsza droga to uruchomienie gotowego modelu, a dopiero potem czytanie prac o jego działaniu. W Pythonie popularna jest biblioteka diffusers od Hugging Face, która udostępnia gotowe modele dyfuzyjne i pozwala eksperymentować z liczbą kroków, ziarnem losowania i opisem. Zanim jednak zanurzysz się w architekturę, zrozum szerszy kontekst: czym jest sztuczna inteligencja, czym jest duży model językowy i jak z modeli powstają agenty AI. Jeśli interesuje Cię zawodowe budowanie aplikacji na modelach, ta droga prowadzi przez ścieżkę AI Engineer.

Najczęstsze pytania o modele dyfuzyjne

Czy Stable Diffusion to LLM?

Nie. Stable Diffusion to model dyfuzyjny generujący obrazy przez odszumianie, a LLM generuje tekst token po tokenie. Oba mogą używać transformerów, ale rozwiązują inne zadanie.

Dlaczego mówi się o „dyfuzji”?

Nazwa wzięła się z analogii do fizyki. Autorzy pracy o denoising diffusion probabilistic models inspirowali się procesami z termodynamiki nierównowagowej, w których uporządkowany układ stopniowo się rozprasza, tak jak obraz rozpuszcza się w szumie w procesie w przód.

Czy modele dyfuzyjne zastąpią LLM?

Na to pytanie nie ma dziś odpowiedzi. Dyfuzyjne modele językowe istnieją i niektóre testy pokazują ich konkurencyjność wobec klasycznych modeli podobnej wielkości, ale klasyczne LLM są znacznie lepiej rozwinięte i używane. Prawdopodobniej oba podejścia będą współistnieć i się mieszać.

Ile kroków odszumiania potrzebuje model dyfuzyjny?

Zależy od modelu i ustawień. Z opisu twórców latent diffusion wynika, że generowanie wymaga wielu sekwencyjnych obliczeń, a w narzędziach liczbę kroków zwykle można zmieniać: więcej kroków to na ogół lepsza jakość kosztem czasu generowania.

Do czego jeszcze służą modele dyfuzyjne poza obrazami?

Do generowania wideo (np. Sora), przewidywania struktur biomolekuł (AlphaFold 3) i, eksperymentalnie, do generowania tekstu (LLaDA). Wspólne mamy to, że wynik powstaje przez stopniowe udoskonalanie całej próbki, a nie przez dopisywanie kolejnych fragmentów.