Skladnost znakov v videoposnetkih umetne inteligence: kako se modeli učijo pomnjenja obrazov

Ena najtrdovratnih izzivov pri generiranju videov UI je bila ohranitev skladnosti znakov skozi kadre. Vprašajte kateregakoli filmarja: zgodba se sesuje v trenutku, ko se obraz glavnega junaka subtilno spremeni med rezih. Leta 2025 smo nazadnje videli, da modeli razrešijo to težavo s arhitekturnimi inovacijami, ki so tako elegantne kot dobro načrtovana pot po težkem vrhu. Kaj te vodi skozi to, kako se sodobni videovni modeli učijo pomnjenja obrazov.

Izziv skladnosti

Tradicionalni difuzijski modeli generirajo vsak okvir s probabilističnim vzorčenjem. To uvaja varianco—koristno za raznolikost, problematično za identiteto. Pri generiranju 10-sekundnega videoposnetka pri 24fps model sprejme 240 zaporednih odločitev, vsaka z priložnostmi za premik.

# Temeljni problem: vsak korak odšumevanja uvaja varianco
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # To vzorčenje uvaja stohastičnost
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Majhne spremembe se s časi kopičijo čez okvire

Zgodnji videovni modeli, kot sta Gen-1 in Pika 1.0, so se vidno borili s tem. Znaki bi se spreminjali v videzu, se malo starali med kadri ali razvijali nekonzistentne značilnosti—kar so praktiki imenovali "premik identitete". Preboj je prišel od tega, da smo skladnost znakov obravnavali ne kot problem obdelave po vrednosti, temveč kot arhitekturnega.

Vdelave, ki ohranjajo identiteto: Osnova

Prva velika inovacija je bila uvedba namenjenih vdelav identitete, ki se ohranijo med procesom generiranja. Namesto da bi se modeli zanašali le na pogojevanje besedila, zdaj vzdržujejo eksplicitne tokene identitete:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Predhodno usposobljen model obraza
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Izvleci lastnosti identitete iz referenčnega okvira
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Medsebojna pozornost s pridobljenimi žetoni identitete
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Ti žetoni identitete se nato injicirajo v difuzijski proces pri vsakem koraku odšumevanja, kar ustvari tisto, kar rada razumem kot "sidrne točke"—kot fiksna zavarovanja na plezalni poti, na katero se lahko vrnete, ko se pogoji poslabšajo.

Medokverna pozornost: Učenje začasne identitete

Drugi preboj je bil arhitekturni: modeli zdaj eksplicitno pozornost namenijo različnim okvirom pri odločanju o videzu znaka. Difuzijski transformerji to naravno podpirajo preko svoje obdelave zalopatalnikov v prostoru in času, toda modeli osredotočeni na skladnost gredo dlje.

Ključna inovacija: Namenjeni sloji pozornosti identitete, ki specifično pozornost namenijo obraznim regijam skozi časno dimenzijo:

class IdentityAwareAttention(nn.Module):
    def __init__(self, dim, num_heads=8):
        super().__init__()
        self.spatial_attn = nn.MultiheadAttention(dim, num_heads)
        self.temporal_attn = nn.MultiheadAttention(dim, num_heads)
        self.identity_attn = nn.MultiheadAttention(dim, num_heads)
 
    def forward(self, x, identity_tokens, face_masks):
        # Standardna prostorska pozornost znotraj okvirov
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Začasna pozornost skozi okvire
        x = rearrange(x, '(b t) n d -> (b n) t d', t=num_frames)
        x = self.temporal_attn(x, x, x)[0] + x
        x = rearrange(x, '(b n) t d -> (b t) n d', n=num_patches)
 
        # Pozornost, specifična za identiteto s pomočjo obraznih regij
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Ta mehanizem trojne pozornosti—prostorska, začasna in specifična za identiteto—omogoča modelu, da sprejema odločitve o videzu, medtem ko eksplicitno sklicuje na vzpostavljeno identiteto in prejšnje okvire.

Primerjava pristopov trenutnih modelov

Glavne platforme za generiranje videov so skladnost znakov izvajale drugače:

Runway-ov Gen-4.5 si zaslužuje posebno omembo. Njihov pristop kombinira pogojevanje s slikami referenc s tem, kar imenujejo "blokade identitete"—pridobljeni žetoni, ki jih je model usposobljen ohranjati ne glede na druge odločitve pri generiranju. Ta arhitekturna izbira je verjetno prispevala k njihovi dominaciji Video Arena.

Paradigma referenčnega okvira

Pomembna sprememba leta 2025 je bila premik k generiranju, pogojeni z referencami. Namesto da bi znake generirali zgolj iz opisa besedila, modeli zdaj sprejmejo referenčne slike, ki vzpostavijo kanoničen videz:

class ReferenceConditionedGenerator:
    def __init__(self, base_model, identity_encoder):
        self.model = base_model
        self.identity_encoder = identity_encoder
 
    def generate(self, prompt, reference_images, num_frames=120):
        # Kodiraj identiteto iz referenčnih slik
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Grupiraj večkratne reference za robustno identiteto
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generiraj z pogojevanjem identitete
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Ravnotežje med skladnostjo in kreativnostjo
            }
        )
        return video

Parameter identity_strength predstavlja pomemben kompromis. Če je premajhen, se model postane tog, nesposoben pokazati naravne spremembe izrazov. Če je prevelik, se premik vrne. Iskanje sladke točke—tipično okrog 0,7-0,85—je deloma umetnost, deloma znanost.

Funkcije izgube za ohranjanje identitete

Usposabljanje teh sistemov zahteva posebne funkcije izgube, ki eksplicitno penalizirajo premik identitete:

Izguba ohranjanja identitete:

L_identity = ||f(G(z, c)) - f(x_ref)||² + λ_temporal * Σ_t ||f(v_t) - f(v_{t+1})||²

Kjer je f predhodno usposobljen kodiralnik prepoznavanja obraza, G je generator, in v_t predstavlja genirane okvire. Prvi člen zagotavlja, da generirani obrazi ustrezajo referencam; drugi penalizira varianco od okvira do okvira.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Ujemanje identitete vsak okvir z referenco
    frame_losses = []
    for frame in generated_video:
        face_embed = face_encoder(frame)
        ref_embed = face_encoder(reference_faces).mean(dim=0)
        frame_losses.append(F.mse_loss(face_embed, ref_embed))
 
    reference_loss = torch.stack(frame_losses).mean()
 
    # Začasna skladnost med sosednjimi okviri
    temporal_losses = []
    for i in range(len(generated_video) - 1):
        curr_embed = face_encoder(generated_video[i])
        next_embed = face_encoder(generated_video[i + 1])
        temporal_losses.append(F.mse_loss(curr_embed, next_embed))
 
    temporal_loss = torch.stack(temporal_losses).mean()
 
    return reference_loss + 0.5 * temporal_loss

Scenariji z več znaki: Težji problem

Skladnost enega znaka je v veliki meri rešena. Scenariji z več znaki—kjer je treba hkrati ohranjati več ločenih identitet—ostajajo zahtevni. Mehanizmi pozornosti lahko medsebojno zamenjajo identitete, kar vodi do prepletanja lastnosti med znaki.

Sedanji pristupi uporabljajo ločene banke identitet:

class MultiCharacterIdentityBank:
    def __init__(self, max_characters=8, embed_dim=768):
        self.banks = nn.ModuleList([
            IdentityBank(embed_dim) for _ in range(max_characters)
        ])
        self.character_separator = nn.Parameter(torch.randn(1, embed_dim))
 
    def encode_multiple(self, character_references):
        all_tokens = []
        for idx, refs in enumerate(character_references):
            char_tokens = self.banks[idx].encode(refs)
            # Dodaj ločilnik, da preprečiš prepletanje
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Ločilni žetoni delujejo kot varovanje med plezalci—ohranjajo jasne identitete, tudi ko delujejo v bližini drug drugega.

Praktične posledice za ustvarjalce

Za tiste, ki te orodja uporabljajo namesto da bi jih gradili, se je pojavilo več praktičnih vzorcev:

Kakovost referenčne slike je odločilna: Referenčne slike višje ločljivosti, dobro osvetljene z nevtralnimi izrazi dajejo bolj skladne rezultate. Model se nauči identitete iz teh sidel, šum pa se širi.

Večkratne reference izboljšajo robustnost: Zagotovljanje 3-5 referenčnih slik iz različnih kotov pomaga modelu zgraditi celovitejšo predstavo identitete. Razmisli, kot bi trianguliral položaj iz več točk.

Inženiring pozivov za skladnost: Eksplicitni opisi identitete v pozovih krepijo vizualno skladnost. "Ženska stara 30 let s kratko rjavo lasma in zelenimi očmi" zagotavlja dodatne omejitve, ki jih model lahko izkoristi.

Pot naprej

Bližamo se pragu, kjer lahko video UI ohranja skladnost znakov, zadostno za pripovedevanje zgodb. Preostali izzivi—subtilna skladnost izrazov, dolgodstrajno generiranje preko 60 sekund, in interakcija med več znaki—se rešujejo.

Pri Bonega.ai nas posebej zanima, kako se ta izboljšanja skladnosti integrirajo s sposobnostmi za razširitev videa. Sposobnost razširjanja obstoječe posnetke ob popolnem ohranjanju skladnosti znakov odpira ustvarjalne možnosti, ki pred 12 meseci preprosto niso bile izvedljive.

Matematična eleganca obravnavanja identitete kot prvotnega arhitekturnega pojma, namesto kot popravka po dogodku, označuje zrelost pri razmišljanju o generiranju videov. Kot vzpostavitev dobro opremljene visokinskega tabora pred pravo na vrh, ta temeljne izboljšave omogočajo daljše, bolj ambiciozne ustvarjalne poti, ki se odprirajo naprej.

Skladnost znakov ni le tehnična metrika—je temelj vizualnega pripovedevanja. In leta 2025 je ta temelj nazadnje trd dovolj, da se lahko gradijo nanjo.