Transformere de difuzie și flux rectificat

U-Net-ul nu este secretul difuziei. Înlocuiți-l cu un Transformer, schimbați programul de zgomot cu un flux în linie dreaptă și obțineți brusc SD3, FLUX și fiecare model text-la-imagine din 2026.

Tip: Învățați + construiți Limbaje: Python Cerințe prealabile: Faza 4 Lecția 10 (Difuzie DDPM), Faza 4 Lecția 14 (ViT), Faza 7 Lecția 02 (Auto-atenție) Timp: ~75 de minute

Obiective de învățare

• Urmăriți evoluția de la U-Net DDPM (Lecția 10) la Diffusion Transformer (DiT), MMDiT (SD3) și DiT cu flux simplu+dublu (FLUX)
• Explicați fluxul rectificat: de ce o traiectorie în linie dreaptă între zgomot și date permite modelelor să eșantioneze în 20 de pași în loc de 1000
• Implementați un bloc DiT mic și o buclă de antrenare cu flux rectificat, ambele în mai puțin de 100 de linii
• Deosebiți variantele de modele (SD3, FLUX.1-dev, FLUX.1-schnell, Z-Image, Qwen-Image) după arhitectură, număr de parametri și licență

Problema

Lecția 10 a construit un DDPM cu un denoiser U-Net. Acea rețetă a dominat perioada 2020–2023: U-Net + program beta + pierdere de predicție a zgomotului. Ea a produs Stable Diffusion 1.5 și 2.1 și DALL-E 2.

Fiecare model text-la-imagine de ultimă generație din 2026 a depășit-o. Stable Diffusion 3, FLUX, SD4, Z-Image, Qwen-Image, Hunyuan-Image — niciunul nu folosește un U-Net. Ele folosesc Diffusion Transformers (DiT). SD3 și FLUX înlocuiesc, de asemenea, programul de zgomot DDPM cu flux rectificat, care îndreaptă traseul de la zgomot la date și permite inferență în 1–4 pași cu variante de consistență sau distilate.

Schimbarea este importantă deoarece a făcut generarea de imagini bazată pe difuzie controlabilă, precisă față de prompt (SD3/SD4 au rezolvat randarea textului) și rapidă pentru producție. A înțelege DiT + flux rectificat înseamnă a înțelege stiva de generare de imagini din 2026.

Notă tehnică a traducerii: Afirmațiile „fiecare”, „niciunul” și „au rezolvat” nu reprezintă proprietăți universale ale generării text-la-imagine. Lucrările DiT și SD3 documentează arhitecturile și rezultatele evaluate în protocoalele lor, iar alegerea unui denoiser, fidelitatea față de prompt și randarea textului depind de model, checkpoint, date și reperul de evaluare. Tratați această prezentare drept un instantaneu al originalului, nu ca un clasament permanent.

Conceptul

De la U-Net la Transformer

• DiT (Peebles & Xie, 2023) — înlocuiește U-Net-ul cu un Transformer asemănător ViT, aplicat patch-urilor latente. Condiționare prin normalizare adaptivă pe straturi (adaptive layer norm, AdaLN).
• MMDiT (SD3, Esser et al., 2024) — două fluxuri cu ponderi separate pentru tokenurile de text și de imagine, care partajează o atenție comună.
• FLUX (Black Forest Labs, 2024) — primele N blocuri au flux dublu, precum SD3, iar blocurile ulterioare concatenează și partajează ponderile (flux simplu) pentru eficiență la adâncime mai mare.
• Z-Image (2025) — un DiT eficient cu flux simplu, la 6B parametri, care contestă ideea de „scalare cu orice preț”.

Fluxul rectificat într-un paragraf

DDPM definește procesul direct ca pe un SDE zgomotos, în care x_t este corupt progresiv. Inversul învățat este un al doilea SDE, rezolvat în 1000 de pași mici.

Fluxul rectificat definește o interpolare în linie dreaptă între date curate și zgomot pur:

x_t = (1 - t) * x_0 + t * epsilon,     t ∈ [0, 1]

Antrenați o rețea să prezică viteza v_theta(x_t, t) = epsilon - x_0 — direcția directă de-a lungul traseului în linie dreaptă de la date curate la zgomot (dx_t/dt). În timpul eșantionării, integrați această viteză invers, pentru a trece de la zgomot spre date. ODE-ul rezultat este mult mai apropiat de o linie dreaptă, astfel încât sunt necesari mult mai puțini pași de integrare pentru eșantionare.

SD3 numește acest lucru Rectified Flow Matching. FLUX, Z-Image și majoritatea modelelor din 2026 folosesc același obiectiv. Inferență tipică: 20–30 de pași Euler (determinist) față de peste 50 de pași DDIM în regimul DDPM vechi. Variantele distilate / turbo / schnell / LCM reduc numărul la 1–4 pași.

Notă tehnică a traducerii: Interpolarea în linie dreaptă definește perechile de antrenare și ținta de viteză; traiectoria obținută la eșantionare este cea indusă de câmpul de viteză învățat și nu este garantat o dreaptă. „Flux rectificat”, „flow matching” și distilarea de consistență sunt familii înrudite, dar obiectivele exacte, parametrizările și solvere-le diferă între implementări. Numărul de pași și comparația cu DDIM depind de checkpoint, scheduler, rezoluție și criteriul de calitate; nici DDIM, nici un DDPM nu impun prin definiție un anumit număr de pași. Lucrările SD3 și LCM nu stabilesc un număr universal de pași pentru toate modelele.

Condiționarea AdaLN

DiT-urile se condiționează după momentul temporal și clasă/text prin normalizare adaptivă pe straturi: prezic scale și shift din vectorul de condiționare și le aplică după LayerNorm. Este mai curată decât modularea de tip FiLM din U-Net-uri și este valoarea implicită în fiecare DiT modern.

cond -> MLP -> (scale, shift, gate)
norm(x) * (1 + scale) + shift, apoi adăugare reziduală * gate

Notă tehnică a traducerii: AdaLN și AdaLN-Zero sunt mecanisme importante în DiT, însă „valoarea implicită în fiecare DiT modern” este o generalizare. Arhitecturile pot folosi forme diferite de condiționare, iar alegerea trebuie verificată în documentația sau lucrarea modelului concret.

Encoderele text din SD3 și FLUX

• SD3 folosește trei encodere text: două modele CLIP + T5-XXL. Reprezentările vectoriale sunt concatenate și introduse în fluxul de imagine drept condiționare textuală.
• FLUX folosește un CLIP-L + T5-XXL.
• Variantele Qwen-Image / Z-Image folosesc encoderele lor text interne, aliniate cu LLM-urile de bază.

Encoderul text este o parte importantă din motivul pentru care SD3/FLUX raționează mult mai bine asupra prompturilor decât SD1.5. Numai T5-XXL are 4,7B parametri.

Notă tehnică a traducerii: Calitatea de respectare a promptului trebuie evaluată pe benchmarkul și checkpointul concret. Denumirea T5-XXL nu desemnează un singur număr de parametri în toate utilizările: checkpointul T5 complet publicat de Google este T5-11B, în timp ce pipeline-urile de difuzie pot încărca doar encoderul unei variante T5-XXL, cu un număr diferit de parametri. Verificați configurația artefactului distribuit, nu doar numele familiei.

Ghidarea fără clasificator rămâne valabilă

Fluxul rectificat schimbă eșantionatorul, nu condiționarea. Ghidarea fără clasificator (classifier-free guidance, CFG; eliminați textul cu probabilitatea de 10% în timpul antrenării, combinați predicțiile condiționată și necondiționată la inferență) funcționează identic cu fluxul rectificat. Majoritatea modelelor din 2026 folosesc o scală de ghidare 3,5–5 — mai mică decât 7,5 în SD1.5, deoarece modelele cu flux rectificat urmează prompturile mai strict în mod implicit.

Notă tehnică a traducerii: CFG se aplică predicției condiționate și necondiționate în parametrizarea aleasă de model (zgomot, viteză, flux ori altă ieșire); formula, probabilitatea de eliminare a condiției și scala utilă nu sunt identice pentru toate modelele cu flux rectificat. Alegeți aceste valori după documentația checkpointului și evaluarea sarcinii.

Consistență, Turbo, Schnell, LCM

Patru nume pentru aceeași idee: distilarea unui model lent, cu mulți pași, într-unul rapid, cu puțini pași.

• LCM (Latent Consistency Model) — antrenați un student care prezice x_0 final din orice x_t intermediar într-un pas.
• SDXL Turbo / FLUX schnell — modele cu 1–4 pași antrenate cu distilare adversarială a difuziei.
• SD Turbo — Consistency Models în stil OpenAI adaptate la difuzia latentă.

Servirea în producție a oricărui model nou livrează atât un checkpoint de „calitate completă”, cât și o variantă „turbo / schnell”. Schnell („rapid” în germană, convenția Black Forest Labs) rulează în 1–4 pași și se potrivește fluxurilor în timp real.

Notă tehnică a traducerii: LCM, Consistency Models, ADD și FLUX.1-schnell nu denumesc același obiectiv de distilare. LCM învață o funcție de consistență de-a lungul traiectoriei, iar ADD (Adversarial Diffusion Distillation) este obiectivul publicat pentru SDXL Turbo și SD Turbo; acestea nu sunt același lucru. Model card-ul FLUX.1-schnell îl descrie separat ca un checkpoint distilat cu guidance, optimizat pentru 1–4 pași. Prin urmare, lista este o taxonomie orientativă după viteză, nu o echivalență tehnică. Nu toate lansările au o variantă turbo/schnell, iar latența în timp real necesită măsurare capăt-la-capăt.

Peisajul modelelor în 2026

Model	Dimensiune	Arhitectură	Licență
Stable Diffusion 3 Medium	2B	MMDiT	SAI Community
Stable Diffusion 3.5 Large	8B	MMDiT	SAI Community
FLUX.1-dev	12B	DiT cu flux dublu + simplu	necomercială
FLUX.1-schnell	12B	aceeași, distilată	Apache 2.0
FLUX.2	—	FLUX.1 iterat	mixtă
Z-Image	6B	S3-DiT (Scalable Single-Stream)	permisivă
Qwen-Image	~20B	DiT + turn text Qwen	Apache 2.0
Hunyuan-Image-3.0	~80B	DiT	cercetare
SD4 Turbo	3B	DiT + distilare	SAI Commercial

FLUX.1-schnell este valoarea implicită open-source în 2026. Z-Image este liderul eficienței. FLUX.2 și SD4 sunt vârfurile actuale de calitate.

Notă tehnică a traducerii: Tabelul, licențele și evaluările „implicit”, „lider” sau „vârf” sunt dependente de versiune, dată, benchmark, hardware și protocol. Pentru utilizare, verificați întotdeauna model card-ul și licența checkpointului exact. În particular, fără o sursă primară publică pentru intrarea exactă, SD4 Turbo nu trebuie tratat drept model, configurație sau licență verificată; iar un nume de familie precum FLUX.2 nu înlocuiește documentația unei versiuni concrete.

De ce contează această schimbare de fază

DDPM + U-Net a funcționat. DiT + flux rectificat funcționează mai bine, mai repede și scalează mai curat. Tranziția este paralelă cu cea de la RNN-uri la Transformere în NLP: ambele arhitecturi au rezolvat aceeași problemă, dar Transformerele au scalat și domină acum. Fiecare lucrare din 2026 despre generarea de imagini, video sau 3D folosește un denoiser cu formă de DiT și de obicei un obiectiv de flux rectificat. DDPM cu U-Net este acum în principal pedagogic (Lecția 10).

Notă tehnică a traducerii: Această analogie și expresiile „fiecare lucrare” sau „în principal pedagogic” sunt interpretarea autorului. U-Net-urile, alte arhitecturi de denoising și alte obiective rămân utilizate; nu deduceți compatibilitatea, calitatea sau costul unui sistem numai din familia arhitecturală.

Construiți

Pasul 1: un bloc DiT cu AdaLN

import torch
import torch.nn as nn


class AdaLNZero(nn.Module):
    """
    Adaptive LayerNorm with a gate. Predicts (scale, shift, gate) from the conditioning.
    Init such that the whole block starts as identity ("zero init").
    """

    def __init__(self, dim, cond_dim):
        super().__init__()
        self.norm = nn.LayerNorm(dim, elementwise_affine=False)
        self.mlp = nn.Linear(cond_dim, dim * 3)
        nn.init.zeros_(self.mlp.weight)
        nn.init.zeros_(self.mlp.bias)

    def forward(self, x, cond):
        scale, shift, gate = self.mlp(cond).chunk(3, dim=-1)
        h = self.norm(x) * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
        return h, gate.unsqueeze(1)


class DiTBlock(nn.Module):
    def __init__(self, dim=192, heads=3, mlp_ratio=4, cond_dim=192):
        super().__init__()
        self.adaln1 = AdaLNZero(dim, cond_dim)
        self.attn = nn.MultiheadAttention(dim, heads, batch_first=True)
        self.adaln2 = AdaLNZero(dim, cond_dim)
        self.mlp = nn.Sequential(
            nn.Linear(dim, dim * mlp_ratio),
            nn.GELU(),
            nn.Linear(dim * mlp_ratio, dim),
        )

    def forward(self, x, cond):
        h, gate1 = self.adaln1(x, cond)
        a, _ = self.attn(h, h, h, need_weights=False)
        x = x + gate1 * a
        h, gate2 = self.adaln2(x, cond)
        x = x + gate2 * self.mlp(h)
        return x

AdaLNZero pornește ca o mapare identitate deoarece ponderile MLP-ului său sunt inițializate cu zero. Antrenarea îndepărtează ușor blocul de identitate; acest lucru stabilizează dramatic modelele Transformer de difuzie adânci.

Notă tehnică a traducerii: În codul de mai sus, inițializarea cu zero face ca ramurile reziduale cu poartă ale fiecărui DiTBlock să pornească nule; ea nu face întregul TinyDiT identitate, deoarece proiecția pe patch-uri, pozițiile și capul de ieșire au propriile parametrizări.

Pasul 2: un DiT mic

def timestep_embedding(t, dim):
    import math
    half = dim // 2
    freqs = torch.exp(-math.log(10000) * torch.arange(half, device=t.device) / half)
    args = t[:, None].float() * freqs[None]
    return torch.cat([args.sin(), args.cos()], dim=-1)


class TinyDiT(nn.Module):
    def __init__(self, image_size=16, patch_size=2, in_channels=3, dim=96, depth=4, heads=3):
        super().__init__()
        self.patch_size = patch_size
        self.num_patches = (image_size // patch_size) ** 2
        self.patch = nn.Conv2d(in_channels, dim, kernel_size=patch_size, stride=patch_size)
        self.pos = nn.Parameter(torch.zeros(1, self.num_patches, dim))
        self.time_mlp = nn.Sequential(
            nn.Linear(dim, dim * 2),
            nn.SiLU(),
            nn.Linear(dim * 2, dim),
        )
        self.blocks = nn.ModuleList([DiTBlock(dim, heads, cond_dim=dim) for _ in range(depth)])
        self.norm_out = nn.LayerNorm(dim, elementwise_affine=False)
        self.head = nn.Linear(dim, patch_size * patch_size * in_channels)

    def forward(self, x, t):
        n = x.size(0)
        x = self.patch(x)
        x = x.flatten(2).transpose(1, 2) + self.pos
        t_emb = self.time_mlp(timestep_embedding(t, self.pos.size(-1)))
        for blk in self.blocks:
            x = blk(x, t_emb)
        x = self.norm_out(x)
        x = self.head(x)
        return self._unpatchify(x, n)

    def _unpatchify(self, x, n):
        p = self.patch_size
        h = w = int(self.num_patches ** 0.5)
        x = x.view(n, h, w, p, p, -1).permute(0, 5, 1, 3, 2, 4).reshape(n, -1, h * p, w * p)
        return x

Notă tehnică a traducerii: Acest TinyDiT presupune imagini pătrate ale căror înălțime și lățime coincid cu image_size și sunt divizibile cu patch_size; altfel numărul tokenurilor nu se potrivește cu self.pos, iar unpatchify reconstruiește greșit forma. În plus, timestep_embedding produce exact dim componente numai când dim este par; păstrați dim par sau adaptați implementarea.

Pasul 3: antrenarea fluxului rectificat

import torch.nn.functional as F

def rectified_flow_train_step(model, x0, optimizer, device):
    model.train()
    x0 = x0.to(device)
    n = x0.size(0)
    t = torch.rand(n, device=device)
    epsilon = torch.randn_like(x0)
    x_t = (1 - t[:, None, None, None]) * x0 + t[:, None, None, None] * epsilon

    target_velocity = epsilon - x0
    pred_velocity = model(x_t, t)

    loss = F.mse_loss(pred_velocity, target_velocity)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item()

Comparați cu pierderea de predicție a zgomotului din DDPM (Lecția 10): aceeași structură, țintă diferită. În loc să prezicem zgomotul epsilon, prezicem viteza epsilon - x_0, care indică de la date către zgomot de-a lungul interpolării în linie dreaptă.

Pasul 4: eșantionatorul Euler

Fluxul rectificat este un ODE. Metoda Euler este cea mai simplă și, pentru un model cu flux rectificat bine antrenat, aproape la fel de precisă ca solvere-le de ordin superior la peste 20 de pași.

@torch.no_grad()
def rectified_flow_sample(model, shape, steps=20, device="cpu"):
    model.eval()
    x = torch.randn(shape, device=device)
    dt = 1.0 / steps
    t = torch.ones(shape[0], device=device)
    for _ in range(steps):
        v = model(x, t)
        x = x - dt * v
        t = t - dt
    return x

20 de pași. Pe un model antrenat, acest lucru produce eșantioane comparabile cu un DDPM de 1000 de pași.

Notă tehnică a traducerii: Precizia Euler față de solvere de ordin superior și comparabilitatea cu un DDPM de 1000 de pași nu sunt garantate. Ele depind de câmpul de viteză învățat, discretizare, scheduler, rezoluție și metrica de evaluare; validați calitatea pe datele și constrângerile proprii.

Pasul 5: test de fum capăt la capăt

import numpy as np

def synthetic_blobs(num=200, size=16, seed=0):
    rng = np.random.default_rng(seed)
    out = np.zeros((num, 3, size, size), dtype=np.float32)
    yy, xx = np.meshgrid(np.arange(size), np.arange(size), indexing="ij")
    for i in range(num):
        cx, cy = rng.uniform(4, size - 4, size=2)
        r = rng.uniform(2, 4)
        mask = (xx - cx) ** 2 + (yy - cy) ** 2 < r ** 2
        colour = rng.uniform(-1, 1, size=3)
        for c in range(3):
            out[i, c][mask] = colour[c]
    return torch.from_numpy(out)

Antrenați un TinyDiT pe acesta cu flux rectificat. După 500 de pași, ieșirile eșantionate ar trebui să arate ca niște pete slabe de culoare.

Notă tehnică a traducerii: Un test pe pete sintetice și un model antrenat de la zero nu demonstrează calitate în 1–4 pași. Eșantionarea cu puțini pași de calitate înaltă necesită de regulă un obiectiv sau o distilare adecvată și trebuie măsurată separat.

Utilizați

Pentru generare reală de imagini cu FLUX / SD3 / Z-Image, diffusers le livrează pe toate cu un API unificat:

from diffusers import FluxPipeline, StableDiffusion3Pipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16,
).to("cuda")

out = pipe(
    prompt="a golden retriever surfing a tsunami, hyperrealistic, studio lighting",
    guidance_scale=0.0,           # schnell was trained without CFG
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
out.save("surf.png")

Trei linii. FLUX.1-schnell în patru pași. Schimbați id-ul modelului cu black-forest-labs/FLUX.1-dev pentru calitate mai bună la 20–30 de pași cu CFG.

Notă tehnică a traducerii: Codul și formularea de mai sus sunt păstrate din original. În exemplul oficial curent al model card-ului FLUX.1-dev, inferența cu FluxPipeline folosește guidance_scale=3.5 și num_inference_steps=50; 20–30 de pași nu este un parametru implicit documentat pentru acest checkpoint. Pentru FLUX.1-schnell, setările din exemplul lecției — guidance_scale=0.0, patru pași și max_sequence_length=256 — sunt compatibile cu documentația oficială curentă.

Pentru SD3:

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.bfloat16,
).to("cuda")
out = pipe(prompt, guidance_scale=3.5, num_inference_steps=28).images[0]

Notă tehnică a traducerii: Disponibilitatea pipeline-urilor, argumentele, cerințele de memorie și licențele sunt dependente de versiunea diffusers și de checkpoint. Consultați documentația pipeline-ului și model card-ul înainte de integrare; exemplul este păstrat exact din lecția-sursă.

Livrați

Această lecție produce:

• outputs/prompt-dit-model-picker.md — alege între SD3, FLUX.1-dev, FLUX.1-schnell, Z-Image și SD4 Turbo, ținând cont de calitate, latență și constrângeri de licență.
• outputs/skill-rectified-flow-trainer.md — scrie o buclă completă de antrenare pentru flux rectificat, cu AdaLN DiT și eșantionare Euler.

Exerciții

1. (Ușor) Antrenați TinyDiT-ul de mai sus pe setul de date sintetic cu pete timp de 500 de pași. Comparați eșantioanele produse cu 10, 20 și 50 de pași Euler.
2. (Mediu) Adăugați condiționare textuală concatenând o reprezentare vectorială de clasă învățată cu reprezentarea temporală (10 „clase” de pete după culoare). Eșantionați cu clasele 0, 5 și 9 și verificați dacă se potrivesc culorile.
3. (Dificil) Calculați distanța Fréchet (proxy FID) între eșantioanele generate de versiunile cu flux rectificat și DDPM ale unei rețele de aceeași dimensiune, antrenate pe aceleași date pentru același număr de pași. Raportați care converge mai rapid.

Notă tehnică a traducerii: În exercițiul 2, concatenarea dublează dimensiunea reprezentării condiției, în timp ce acest TinyDiT așteaptă cond_dim=dim; proiectați vectorul concatenat înapoi la dim sau adunați reprezentările înainte de time_mlp. În exercițiul 3, FID înseamnă Fréchet Inception Distance: se calculează între distribuțiile de caracteristici Inception ale unor eșantioane suficiente, cu același extractor și același protocol. O distanță Fréchet în spațiul pixelilor este numai un proxy și nu trebuie numită FID.

Termeni-cheie

Termen	Ce spun oamenii	Ce înseamnă de fapt
DiT	„Transformer de difuzie”	Transformer care înlocuiește U-Net-ul drept denoiser de difuzie; operează pe latenți împărțiți în patch-uri
AdaLN	„Normalizare adaptivă pe straturi”	Condiționare după moment temporal/text prin scale, shift, gate învățate, aplicate după LayerNorm; standard în fiecare DiT modern
MMDiT	„DiT multimodal (SD3)”	Fluxuri cu ponderi separate pentru tokenurile de text și imagine, care partajează o auto-atenție comună
Flux simplu / flux dublu	„Trucul FLUX”	Primele N blocuri au flux dublu (ponderi separate pentru fiecare modalitate), ulterior au flux simplu (concatenare + ponderi partajate) pentru eficiență
Flux rectificat	„Zgomot-la-date în linie dreaptă”	Interpolare liniară între date și zgomot; rețeaua prezice viteza; sunt necesari mai puțini pași ODE la inferență
Ținta de viteză	„epsilon - x_0”	Ținta de regresie în fluxul rectificat; indică de la date curate spre zgomot
Ghidare CFG	„Ghidare fără clasificator”	Combină predicțiile condiționată și necondiționată; se folosește în continuare la modelele cu flux rectificat
Schnell / turbo / LCM	„Distilare în 1–4 pași”	Variante cu puțini pași, distilate din modele de calitate completă; pentru timp real în producție

Lecturi suplimentare

• Scalable Diffusion Models with Transformers (Peebles & Xie, 2023) — lucrarea despre DiT
• Scaling Rectified Flow Transformers (Esser et al., lucrarea SD3) — MMDiT și flux rectificat la scară
• Model card și raport tehnic FLUX.1 (Black Forest Labs) — detalii despre fluxul dublu + simplu
• Z-Image: Efficient Image Generation Foundation Model (2025) — DiT cu flux simplu la 6B
• Elucidating the Design Space of Diffusion (Karras et al., 2022) — referința pentru fiecare compromis de proiectare a difuziei
• Latent Consistency Models (Luo et al., 2023) — modul în care LCM-LoRA oferă inferență în 4 pași

Sursă: Originalul în limba engleză

Navigare: ← Lecția 04.22 — 3D Gaussian Splatting de la zero · Faza 4 — Viziune computerizată · Lecția 04.24 — SAM 3 și segmentarea cu vocabular deschis → · Catalog complet