Transformers de difusió: l'arquitectura que revoluciona la generació de vídeo el 2025

L'ascens al cim de la generació de vídeo ha estat una escalada metòdica, on cada innovació arquitectònica s'ha construït sobre l'anterior. El 2025, hem arribat al que sembla un nou pic amb els transformers de difusió, una fusió elegant que està reformant fonamentalment com pensem sobre la generació temporal. Permeteu-me guiar-vos a través del paisatge tècnic que ha emergit, molt semblant a navegar per les crestes entre el Dent Blanche i el Matterhorn.

La convergència arquitectònica

Els models tradicionals de generació de vídeo lluitaven amb dos reptes fonamentals: mantenir la consistència temporal entre fotogrames i escalar a seqüències més llargues. La innovació va arribar quan els investigadors es van adonar que el marc probabilístic dels models de difusió podia millorar-se amb els mecanismes d'atenció dels transformers, creant el que ara anomenem transformers de difusió latent.

class DiffusionTransformer(nn.Module):
    def __init__(self, latent_dim=512, num_heads=16, num_layers=24):
        super().__init__()
        self.patch_embed = SpacetimePatchEmbed(latent_dim)
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(
                d_model=latent_dim,
                nhead=num_heads,
                dim_feedforward=latent_dim * 4,
                norm_first=True  # Pre-normalització per estabilitat
            ),
            num_layers=num_layers
        )
        self.denoise_head = nn.Linear(latent_dim, latent_dim)
 
    def forward(self, x_t, timestep, conditioning=None):
        # Extreure patches espai-temps - la innovació clau
        patches = self.patch_embed(x_t)
 
        # Afegir embeddings posicionals i temporals
        patches = patches + self.get_pos_embed(patches.shape)
        patches = patches + self.get_time_embed(timestep)
 
        # Processament del transformer amb normalització QK
        features = self.transformer(patches)
 
        # Predir soroll per a la difusió
        return self.denoise_head(features)

L'elegància rau en tractar el vídeo no com una seqüència d'imatges, sinó com un volum espai-temporal unificat. L'enfocament d'OpenAI amb Sora 2 processa vídeos a través de dimensions espacials i temporals, creant el que anomenen "patches espai-temporals", de manera anàloga a com els Vision Transformers processen imatges, però estès a la dimensió temporal.

Fonaments matemàtics: més enllà del simple eliminació de soroll

La innovació matemàtica central estén la formulació estàndard de difusió. En lloc de l'enfocament tradicional on modelem p_θ(x_{t-1}|x_t), els transformers de difusió operen sobre representacions latents comprimides:

Funció de pèrdua: L_DT = E[||ε - ε_θ(z_t, t, c)||²]

On z_t representa la codificació espai-temporal latent, i el transformer ε_θ prediu soroll condicionat tant per la posició temporal t com pel condicionament opcional c. L'avanç crític és que la normalització Query-Key estabilitza aquest procés:

Atenció: Attention(Q, K, V) = softmax(Q_norm · K_norm^T / √d_k) · V

Aquesta modificació aparentment simple, normalitzar Q i K abans de calcular l'atenció, millora dramàticament l'estabilitat d'entrenament a escala, permetent que els models s'entrenin eficientment en sistemes distribuïts. El mateix enfocament de restricció bidireccional impulsa la difusió paral·lelitzada per a generació d'ultra alta resolució.

Generació audiovisual multi-etapa: l'arquitectura de Veo 3

Veo 3 de Google DeepMind va introduir una arquitectura multi-etapa sofisticada: un transformer de 12 mil milions de paràmetres genera fotogrames clau a intervals de 2 segons, mentre que una U-Net de 28 mil milions de paràmetres interpola fotogrames intermedis, i un motor de síntesi d'àudio separat de 9 mil milions de paràmetres produeix bandes sonores sincronitzades. Penseu-ho com capturar tant la bellesa visual com el so d'una allau a través de sistemes especialitzats coordinats.

class MultiStageVideoEncoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.keyframe_generator = KeyframeTransformer()  # 12B params
        self.frame_interpolator = InterpolationUNet()    # 28B params
        self.audio_synthesizer = AudioGenerator()        # 9B params
 
    def generate(self, prompt, duration=8):
        # Generar primer els fotogrames clau
        keyframes = self.keyframe_generator(prompt, num_frames=duration//2)
 
        # Interpolar fotogrames intermedis
        full_video = self.frame_interpolator(keyframes)
 
        # Generar àudio sincronitzat
        audio = self.audio_synthesizer(full_video, prompt)
 
        return full_video, audio

El procés de difusió genera ambdues modalitats amb sincronització temporal, aconseguint una precisió de sincronització labial de menys de 120 mil·lisegons per al diàleg.

Panorama actual de models i rendiment

Les diferències arquitectòniques entre els models actuals mostren enfocaments diferents per a la generació de vídeo:

El que és particularment interessant és com diferents models optimitzen per a la longitud de seqüència a través de diversos patrons d'atenció:

def hierarchical_attention(patches, hierarchy_levels=3):
    """
    Refinament d'atenció progressiu de gruixut a fi
    Similar a escalar: establir camp base, després avançar cap al cim
    """
    attention_maps = []
 
    for level in range(hierarchy_levels):
        window_size = 2 ** (hierarchy_levels - level)
        local_attn = compute_windowed_attention(patches, window_size)
        attention_maps.append(local_attn)
 
    # Combinar atenció multi-escala
    return torch.stack(attention_maps).mean(dim=0)

Avenços en arquitectura conscient del moviment

El 2025 hem vist l'emergència d'arquitectures conscients del moviment que modelen explícitament les dinàmiques temporals. El marc Motion-Aware Generative (MoG), proposat per investigadors de la Universitat de Nanjing i Tencent, aprofita la guia de moviment explícita dels models d'interpolació basats en flux per millorar la generació de vídeo. El marc integra la guia de moviment tant a nivells latents com de característiques, millorant significativament la consciència de moviment en models de generació de vídeo pre-entrenats a gran escala.

Aquesta separació del processament de moviment i aparença permet un control millorat sobre les dinàmiques temporals mantenint la consistència visual. Imagineu poder ajustar la velocitat d'una allau mentre manteniu cada floc de neu perfectament renderitzat.

Optimització per a producció: del laboratori a l'aplicació

El veritable triomf de 2025 no és només la millora de qualitat, és l'eficiència de desplegament. Les optimitzacions TensorRT per a models de difusió basats en transformer aconsegueixen acceleracions significatives:

# Pipeline de generació estàndard
model = DiffusionTransformer().cuda()
frames = model.generate(prompt, num_frames=120)  # 5 segons de vídeo
 
# Pipeline optimitzat amb TensorRT
import tensorrt as trt
optimized_model = optimize_with_tensorrt(model,
                                         batch_size=1,
                                         precision='fp16',
                                         use_flash_attention=True)
frames = optimized_model.generate(prompt, num_frames=120)  # Significativament més ràpid

El Fine-Tuning eficient en paràmetres mitjançant LoRA ha democratitzat la personalització. Els equips ara poden adaptar models de vídeo pre-entrenats amb només l'1% dels paràmetres originals:

class VideoLoRA(nn.Module):
    def __init__(self, base_model, rank=16):
        super().__init__()
        self.base_model = base_model
 
        # Injectar adaptacions de rang baix
        for name, module in base_model.named_modules():
            if isinstance(module, nn.Linear):
                # Només entrenar aquestes matrius petites
                setattr(module, 'lora_A', nn.Parameter(torch.randn(rank, module.in_features)))
                setattr(module, 'lora_B', nn.Parameter(torch.randn(module.out_features, rank)))

Mirant endavant: la propera ascensió

La convergència cap a arquitectures unificades continua. El model BAGEL de ByteDance (7B paràmetres actius amb arquitectura Mixture-of-Transformers) i els models Transfusion de Meta són pioners en arquitectures de transformer únic que gestionen tant tasques autoregressives com de difusió. A Bonega.ai, estem particularment entusiasmats amb les implicacions per al processament de vídeo en temps real. Imagineu estendre el vostre metratge existent sense discontinuïtats amb contingut generat per IA que coincideixi perfectament en estil i moviment.

L'elegància matemàtica dels transformers de difusió ha resolt reptes fonamentals en la generació de vídeo: mantenir la coherència al llarg del temps mentre s'escala eficientment. Com algú que ha implementat aquestes arquitectures des de zero, us puc dir que la sensació és com arribar a un fals cim, només per descobrir que el veritable pic revela una vista encara més grandiosa per davant.

Les eines i marcs que emergeixen al voltant d'aquests models, des de mètodes d'adaptació sense entrenament fins a estratègies de desplegament al límit, suggereixen que estem entrant en una era on la generació de vídeo d'alta qualitat es torna tan accessible com ho era la generació d'imatges el 2023. L'escalada continua, però hem establert un camp base sòlid a una altitud que abans es pensava inassolible.