Tegelaste konsistentsus tehisintellekti videodes: kuidas mudelid õpivad nägesid meeles pidama

Üks püsivamaid väljakutseid tehisintellekti videogeeneermises on tegelase konsistentsuse säilitamine kaadrite vahel. Küsi igalt filmitegijalt: lugu langeb lagunema, kui teie peategelase nägu muutub kaadrite vahel veidi. 2025. aastaks oleme lõpuks näinud, kuidas mudelid lahendavad selle probleemi arhitektuuriuuenduste abil, mis tunnevad sama elegantsed kui hästi planeeritud marsruut raskele mäele. Laske mul teil näidata, kuidas kaasaegsed videomudelid õpivad nägesid meeles pidama.

Konsistentsuse väljakutse

Traditsioonilised difusioonimudelid genereerivad iga kaadri probabilistliku valimiga. See tekitab varieeruvust—kasulik mitmekesisuse jaoks, kuid probleemaatiline identiteedi jaoks. 10-sekundilise video genereerimisel 24 fps juures teeb mudel 240 järjestikust otsust, millest igaühel on võimalus lahknemiseks.

# Põhiprobleem: iga denoising samm tekitab varieeruvust
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # See valim tekitab stohhastsusi
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Väikesed muutused kogunevad kaadrite vahel

Varasemad videomudelid nagu Gen-1 ja Pika 1.0 võitlesid selle nähtava probleemiga. Tegelased muutsid välimust, vanandasid kaadrite vahel või arendasid vasturääkivaid jooni—mida praktikud kutsusid "identiteedi lahknemiseks". Läbimurre oli käsitleda tegelaste konsistentsi mitte järeltöötluse probleemina, vaid arhitektuurina.

Identiteeti säilitavad embedingud: alus

Esimene suurem uuendus oli tutvustada spetsiaalseid identiteedi embedinguid, mis püsivad genereerimisprotsessi jooksul. Selle asemel, et tugineda ainult teksti tingimusele, säilitavad mudelid nüüd otseseid identiteedi märke:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Eelnevalt treenitud näo mudel
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Eraldage identiteedi omadused referentskaadrist
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Risttähelepanu õpitavate identiteedi märkidega
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Need identiteedi märked süstitakse difusiooniprotsessi igal denoising sammul, luues millest ma meeldin mõelda kui "ankurpunktidest"—nagu fikseeritud kaitse peal, millele saad alati tagasi klipeerida, kui tingimused muutuvad ebakindlaks.

Kaadrite vaheline tähelepanu: ajaline identiteedi õppimine

Teine läbimurre oli arhitektuuri tasandil: mudelid peavad nüüd otseselt tähelepanu kaadrite vahel, tehes otsuseid tegelase välimuse kohta. Difusiooni transformerid toetavad seda loomulikult oma ruumiajapaiga töötluse kaudu, kuid konsistentsusele fokusseeritud mudelid lähevad kaugemale.

Põhiline uuendus: spetsiaalsed identiteedi tähelepanu kihid, mis tegelevad eriti näo piirkondade tähelepanuga ajalises dimensioonis:

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):
        # Tavaline ruumiline tähelepanu kaadrites
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Ajaline tähelepanu kaadrite vahel
        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)
 
        # Identiteedi spetsiifiline tähelepanu kasutades näo piirkondi
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

See kolmikene tähelepanu mehhanismi—ruumiline, ajaline ja identiteedi spetsiifiline—võimaldab mudelil teha välimuse otsuseid, viidates otseselt nii kehtestatud identiteedile kui ka eelmistele kaadritele.

Praeguste mudelite lähenemisviiside võrdlus

Suured video genereerimise platvormid on rakendanud tegelaste konsistentsi erinevalt:

Runway Gen-4.5 väärib siin erilist mainingut. Nende lähenemine kombineerib referentsikaadrite tingimusimist millega nad kutsuvad "identiteedi lukke"—õpitud märke, mille mudel on treenitud säilitama sõltumata muudest generatiivsetest otsustest. See arhitektuuri valik pidi tõenäoliselt kaasa minema nende Video Arena domineerumisele.

Referentsikaadrite paradigma

Oluline muutus 2025. aastal on liikumine referentsist tingimusimise suunas. Selle asemel, et genereerida tegelased puhtalt tekstikirjelduste järgi, aktsepteerivad mudelid nüüd referentskujutisi, mis kehtestab kanoonilise välimuse:

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):
        # Kodeerige identiteet referentskujutistest
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Ühendage mitu referentsi robustse identiteedi jaoks
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Genereerige identiteedi tingimusega
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Tasakaalustab konsistentsust vs loovust
            }
        )
        return video

Parameeter identity_strength kujutab olulist valikut. Liiga kõrgelt ja mudel muutub jäigaks, suutmatu loomulikku väljendusmuutust näidata. Liiga madalalt ja lahknemine naaseb. Magusapunkti leidmine—tavaliselt umbes 0,7-0,85—on osa kunsti, osa teadust.

Kaotuse funktsioonid identiteedi säilitamiseks

Nende süsteemide treenimine nõuab spetsialiseeritud kaotuse funktsioone, mis otseselt penaliseerivad identiteedi lahknemist:

Identiteedi säilitamise kaotus:

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

Kus f on eelnevalt treenitud näo tunnuse kodeerija, G on generaator ja v_t kujutab genereeritud kaadrid. Esimene termin tagab, et genereeritud näod vastavad referentsidele; teine penaliseerib kaadrite vahelist muutust.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Kaadrite kaupa identiteedi sobitamine referentsiga
    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()
 
    # Ajaline konsistentsus külgnevate kaadrite vahel
    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

Mitut tegelast kuuluvad stsenaariumid: raskem probleem

Ühe tegelase konsistentsus on suures osas lahendatud. Mitme tegelase stsenaariumid—kus tuleb säilitada mitut erinevat identiteeti samaaegselt—jäävad väljakutsete sekka. Tähelepanu mehhanismid võivad identiteedid segada, põhjustades joonte voolavust tegelaste vahel.

Praegused lähenemisviiised kasutavad eraldi identiteedi panku:

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)
            # Lisage eraldaja segamise vältimiseks
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Eraldaja märgid toimivad nagu petsid ronijate vahel—säilitavad eraldis identiteetid isegi siis, kui nad on tihedas läheduses.

Praktiline mõju loojatele

Nende tööriistade kasutajatele e neile, kes ei õpi neid ehitada, on ilmnenud mitu praktilist mudelit:

Referentsikaadrite kvaliteet on oluline: Kõrgema resolutsiooniga, hästi valgustatud referentsikaadrid neutraalsete väljendistega annavad ühtsemad tulemused. Mudel õpib identiteedi neist ankurtest ja müra levib.

Mitu referentsi parandavad vastupidavust: Kolme kuni viie referentskujutise esitamine eri nurkadest aitab mudelil ehitada terviklikuma identiteedi esitust. Mõelge sellele kui positsiooni trianguleerimine mitmetest punktidest.

Arutelu inseneeria konsistentsuse jaoks: Otsesed identiteedi kirjeldused arutlustes tugevdavad visuaalset konsistentsi. "30-aastane naine lühikeste pruunide juustega ja roheline silmad" pakub täiendavaid piiranguid, mida mudel saab kasutada.

Tee edasi

Me lähenemegi lävedele, kus tehisintellekti genereeritud video võib säilitada tegelaste konsistentsi, mis on piisav narratiivse jutustamise jaoks. Ülejäänud väljakutsed—subtiilined väljenduse konsistentsus, pikemaaalised genereerimised üle 60 sekundi ja mitme tegelase interaktsioon—käiakse aktiivselt.

Bonega.ai juures olemegi eriti huvitatud, kuidas need konsistentsuse parandused integreeritakse video laienduse võimalustega. Võimalus laiendada olemasolevat sisu säilitades perfektse tegelaste konsistentsi avab loomingulisi võimalusi, mis olid lihtsalt teostavad 12 kuud tagasi.

Matemaatiline elegants, mille kohaselt käsitletakse identiteeti esimese klassi arhitektuuri mõistena, mitte tagasivaatava parandusena, märgib küpsemist selles, kuidas mõtleme video genereerimisele. Nagu hästi varustatud kõrgkooli kehtestamine enne tippu survet, võimaldavad need alustalause parandused pikemaid, ambitsioonikamaid loovaid teekonda, mis ees ootavad.

Tegelaste konsistentsus ei ole vaid tehniline mõõdik—see on visuaalse jutustamise alus. Ja 2025. aastal on see alus lõpuks piisavalt tugev, et sellele ehitada.