Hahmon johdonmukaisuus tekoälyvideossa: Kuinka mallit oppivat muistamaan kasvoja

Yksi tekoälyvideogeneroinnin suurimmista haasteista on ollut hahmon johdonmukaisuuden säilyttäminen otoksen yli. Kysy miltään elokuvaajalta: tarina hajoaa heti, kun päähenkilön kasvot muuttuvat hieman leikkausten välillä. Vuonna 2025 olemme lopulta nähneet mallien ratkaisevat tämän ongelman arkkitehtonisilla innovaatioilla, jotka tuntuvat yhtä eleganteilla kuin hyvin suunniteltu reitti vaikeaa huippua ylöspäin. Käydään läpi, kuinka moderniset videnomallit oppivat muistamaan kasvoja.

Johdonmukaisuuden haaste

Perinteiset diffuusiomallit generoivat jokaisen kehyksen todennäköisyysperusteisen näyttöönottamisen avulla. Tämä lisää vaihtelua—hyödyllistä monimuotoisuutta varten, ongelmallista identiteetin kannalta. 10 sekunnin videon generoinnissa 24 fps:llä malli tekee 240 peräkkäistä päätöstä, joissa jokaisessa on mahdollisuus poikkeamalle.

# Ydinongelmaa: jokainen denoising-vaihe lisää satunnaisuutta
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Tämä näyttöönotto lisää stokastisuutta
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Pienet vaihtelut kertyvät kehysten yli

Varhaiset videnomallit, kuten Gen-1 ja Pika 1.0, kamppailivat näkyvästi tämän kanssa. Hahmot muuttaisivat ulkonäköään, vanhenisivat hieman otoksen välillä tai kehittäisivät epäjohdonmukaisia piirteitä—mitä ammattilaiset kutsuvat "identiteetin vaeltamiseksi". Läpimurto tuli siitä, että hahmon johdonmukaisuutta käsiteltiin ei jälkikäsittelyn ongelmana, vaan arkkitehtonisena.

Identiteettiä säilyttävät upotukset: Perusta

Ensimmäinen suuri innovaatio oli dedikoitujen identiteettiupotuksien ottaminen käyttöön, jotka pysyvät generoinnin prosessin yli. Pelkän tekstisidonnaisen riippuvuuden sijasta mallit säilyttävät nyt eksplisiittiset identiteettitokenit:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Esijärjestetty kasvojen malli
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Poimi identiteettipiirteet viitekeykystä
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Ristihuomio opittujen identiteettitokenien kanssa
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Nämä identiteettitokenit injektoidaan sitten diffuusioprosessiin jokaisen denoising-vaiheen aikana, mikä luo niin sanotut "ankkuripisteet"—kuten kiinteät suojaukset kiipeilyreiteillä, joihin voit aina palata, kun olosuhteet muuttuvat epävarmaksi.

Kehystenväliset huomio: Ajallisen identiteetin oppiminen

Toinen läpimurto oli arkkitehtoniikassa: mallit nyt eksplisiittisesti kiinnittävät huomion kehyksiin yli tehdessään päätöksiä hahmon ulkonäköön. Diffuusiotransformerit tukevat luonnollisesti tätä niiden spacetime-patch-käsittelyn kautta, mutta johdonmukaisuuteen keskittyvät mallit menevät pidemmälle.

Avain-innovaatio: Dedikoidut identiteettihuomio-kerrokset, jotka erityisesti kiinnittävät huomion kasvoalueisiin ajallisen dimension yli:

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):
        # Tavallinen tilannollinen huomio kehysten sisällä
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Ajallinen huomio kehyksien yli
        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)
 
        # Identiteettiin kohdistuva huomio kasvoalueita käyttäen
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Tämä kolminkertainen huomio-mekanismi—tilannollinen, ajallinen ja identiteettiin kohdistuva—antaa mallille mahdollisuuden tehdä ulkonäköpäätöksiä samalla kun eksplisiittisesti viittaa sekä vakiintuneeseen identiteettiin että edellisiin kehyksiin.

Nykyisten mallien lähestymistavat vertailussa

Suuret videongeneroinnin alustat ovat ottaneet hahmon johdonmukaisuuden käyttöön eri tavoin:

Runwayn Gen-4.5 ansaitsee erityismaininnan tässä. Heidän lähestymistapansa yhdistää viitekuvan ehdollistamisen siihen, mitä he kutsuvat "identiteetin lukitukseksi"—opetuista tokeneista, joita malli koulutetaan säilyttämään riippumatta muista generatiivisista päätöksistä. Tämä arkkitehtoniikka valinta todennäköisesti myötävaikutti heidän Video Arena hallitsevuuteensa.

Viitekehys-paradigma

Merkittävä muutos 2025:ssa on ollut siirtyminen viitesidonnaisen generointiin. Sen sijaan, että hahmot generoitaisiin puhtaasti tekstikuvausten perusteella, mallit nyt hyväksyvät viitekuvia, jotka luovat kanonisen ulkonäön:

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):
        # Koodaa identiteetti viitekuvista
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Pooli useita viitteitä vahvempaan identiteettiin
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generoi identiteetin ehdollistamisen kanssa
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Tasapainottaa johdonmukaisuuden luovuuteen
            }
        )
        return video

identity_strength-parametri edustaa tärkeää kompromissia. Liian korkea, ja malli muuttuu jäykäksi, kykenemättömäksi osoittamaan luonnollista ilmeiden vaihtelua. Liian matala, ja poikkeama palaa. Pehmeän pisteen löytäminen—tyypillisesti noin 0,7–0,85—on osittain taidetta, osittain tiedettä.

Häviöfunktiot identiteetin säilyttämiseen

Näiden järjestelmien kouluttaminen vaatii erikoistuneita häviöfunktioita, jotka eksplisiittisesti rankaisevat identiteetin poikkeamasta:

Identiteetin säilyttämisen häviö:

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

Missä f on esikoulutettu kasvojen tunnistusentaulakooderi, G on generaattori, ja v_t edustaa generoituja kehyksiä. Ensimmäinen termi varmistaa, että generoitut kasvot vastaavat viitteitä; toinen rankaisee kehystenvälistä vaihtelua.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Kehyskohtainen identiteetin vastaavuus viitteeseen
    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()
 
    # Ajallinen johdonmukaisuus vierekkäisten kehysten välillä
    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

Monihahmo-skenaariot: Vaikeampi ongelma

Yksihahmoinen johdonmukaisuus on pitkälti ratkaistu. Monihahmo-skenaariot—joissa useat erilliset identiteetit on säilytettävä samanaikaisesti—jäävät haastaviksi. Huomio-mekanismit voivat sekoittaa identiteetteja, mikä johtaa piirteiden vuotamiseen hahmojen välillä.

Nykyiset lähestymistavat käyttävät erillisiä identiteettipankkeja:

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)
            # Lisää erotin sekaannuksen estämiseksi
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Erottimen tokenit toimivat kuin väliasiat kiipeilijöiden välillä—säilyttävät erilliset identiteetit jopa tilanteissa, joissa ne toimivat lähellä toisiaan.

Käytännön vaikutukset luojille

Niille, jotka käyttävät näitä työkaluja ilman niiden rakentamista, useita käytännön malleja on ilmennyt:

Viitekuvan laatu merkitsee: Suuremman resoluution, hyvin valaistut viitekuvat neutraalilla ilmeellä tuottavat johdonmukaisempia tuloksia. Malli oppii identiteetin näistä ankkureista, ja kohina leviää.

Useammat viitteet parantavat kestävyyttä: 3–5 viitekuvan tarjoaminen eri kulmista auttaa mallia rakentamaan täydellisemmän identiteettiesityksen. Ajattele sitä kolmioinnin asennona useista pisteistä.

Kehotteen suunnittelu johdonmukaisuudelle: Eksplisiittiset identiteettikuvaukset kehottesissa vahvistavat visuaalista johdonmukaisuutta. "30-vuotias nainen lyhyillä ruskeilla hiuksilla ja vihreillä silmillä" tarjoaa lisärajoituksia, joita malli voi hyödyntää.

Tulevaisuus edessä

Lähestymme kynnystä, jossa tekoälyllä generoitu video voi säilyttää hahmon johdonmukaisuuden riittävänä kertomustarinalliselle kerrontalle. Jäljellä olevat haasteet—hienovarainen ilmeiden johdonmukaisuus, pitkämuotoinen generointi yli 60 sekunnin ja monihahmo-vuorovaikutus—ratkaistaan aktiivisesti.

Bonega.ai:ssa olemme erityisesti kiinnostuneita siitä, kuinka nämä johdonmukaisuuden parantamiset integroituvat videolaajennus kyvykkyyksiin. Kyky laajentaa olemassa olevaa kuvamateriaalia samalla kun säilytetään täydellinen hahmon johdonmukaisuus avaa luovia mahdollisuuksia, joita ei ollut mahdollista 12 kuukautta sitten.

Matemaattinen eleganssi siitä, että identiteettiä käsitellään ensimmäisen luokan arkkitehtonisena huolena sen sijaan, että se olisi jälkikäteinen korjaus, merkitsee kypsyyttä siinä, kuinka ajattelemme videogeneroinnista. Samoin kuin hyvin varustetun leirinvoinnin perustaminen ennen huippujalansyöntia, nämä perustuvat parannukset mahdollistavat pidemmät, kunnianhimoisemmat luovat matkat, jotka odottavat eteenpäin.

Hahmon johdonmukaisuus ei ole vain tekninen mittari—se on visuaalisen kerronnan perusta. Ja vuonna 2025 se perusta on vihdoin vahva tarpeeksi rakentaa päälle.