Spójność postaci w wideo AI: Jak modele uczą się zapamiętywać twarze

Jednym z najtrudniejszych problemów w generowaniu wideo AI było utrzymanie spójności postaci w różnych ujęciach. Zapytaj każdego filmowca: historia rozpada się w momencie, gdy twarz twojego protagonisty subtelnie się zmienia między cięciami. W 2025 roku wreszcie zobaczyliśmy, jak modele poradzą sobie z tym problemem dzięki innowacjom architektonicznym, które są równie eleganckie jak dobrze zaplanowana trasa na trudny szczyt. Pozwól, że oprowadzę cię przez to, jak nowoczesne modele wideo uczą się zapamiętywać twarze.

Wyzwanie spójności

Tradycyjne modele dyfuzji generują każdą klatkę poprzez próbkowanie probabilistyczne. Wprowadza to zmienność—przydatną dla różnorodności, problematyczną dla tożsamości. Podczas generowania 10-sekundowego wideo z prędkością 24fps model podejmuje 240 kolejnych decyzji, każda z możliwością znoszenia się błędów.

# Główny problem: każdy krok denoisingu wprowadza zmienność
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # To próbkowanie wprowadza stochastyczność
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Drobne wariacje gromadzą się przez klatki

Wczesne modele wideo, takie jak Gen-1 i Pika 1.0, wyraźnie borykały się z tym problemem. Postacie zmieniały wygląd, nieznacznie starzały się między ujęciami lub wykazywały niespójne cechy—co praktycy nazywali „dryfem tożsamości". Przełom pojawił się, gdy traktowano spójność postaci nie jako problem przetwarzania końcowego, ale jako architektoniczny.

Osadzenia zachowujące tożsamość: Fundament

Pierwszą dużą innowacją było wprowadzenie dedykowanych osadzeń tożsamości, które utrzymują się przez cały proces generowania. Zamiast polegać wyłącznie na uwarunkowaniu tekstowym, modele teraz utrzymują jawne tokeny tożsamości:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Wstępnie trenowany model twarzy
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Ekstrakt cechy tożsamości z obrazu referencyjnego
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Krzyżowa atencja z nauczonych tokenów tożsamości
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Te tokeny tożsamości są następnie wstrzykiwane do procesu dyfuzji na każdym kroku denoisingu, tworząc to, co lubię uważać za „punkty zakotwiczenia"—jak stałe asekuracje na trasie wspinaczki, do których zawsze możesz się przymocować, gdy warunki stają się niepewne.

Atencja między klatkami: Uczenie się czasowej tożsamości

Drugi przełom był architektoniczny: modele teraz jawnie patrzą na klatki podczas podejmowania decyzji o wyglądzie postaci. Diffusion transformers naturalnie wspierają to poprzez ich przetwarzanie przestrzenno-czasowych łat, ale modele skoncentrowane na spójności idą dalej.

Kluczowa innowacja: Dedykowane warstwy atencji tożsamości, które specyficznie patrzą na regiony twarzy w wymiarze czasowym:

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):
        # Standardowa atencja przestrzenna w obrębie klatek
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Atencja czasowa między klatkami
        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)
 
        # Atencja specyficzna dla tożsamości przy użyciu regionów twarzy
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Ten mechanizm potrójnej atencji—przestrzenna, czasowa i specyficzna dla tożsamości—pozwala modelowi podejmować decyzje dotyczące wyglądu, jednocześnie wyraźnie odwołując się do ustalonej tożsamości i poprzednich klatek.

Porównanie obecnych podejść modeli

Główne platformy generowania wideo wdrożyły spójność postaci w różny sposób:

Gen-4.5 Runway zasługuje tutaj na szczególną uwagę. Ich podejście łączy uwarunkowanie obrazu referencyjnego z tym, co oni nazywają „zamkami tożsamości"—nauczonych tokenów, które model jest trenowany do zachowania niezależnie od innych decyzji generatywnych. Ten wybór architektoniczny prawdopodobnie przyczynił się do ich dominacji w Video Arena.

Paradygmat klatki referencyjnej

Znaczny przesun w 2025 roku był przesunięciem w kierunku generowania uwarunkowanego referencyjnie. Zamiast generować postacie czysto z opisów tekstowych, modele teraz akceptują obrazy referencyjne, które ustalają kanoniczny wygląd:

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):
        # Kodowanie tożsamości z obrazów referencyjnych
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Pula wielu referencji dla solidnej tożsamości
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generowanie z uwarunkowaniem tożsamości
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Równoważy spójność vs kreatywność
            }
        )
        return video

Parametr identity_strength reprezentuje ważny kompromis. Zbyt wysoki, a model staje się sztywny, niezdolny do pokazania naturalnych zmian wyrazu. Zbyt niski, a dryfuje wraca. Znalezienie słodkiego miejsca—typowo wokół 0,7-0,85—jest częściowo sztuką, częściowo nauką.

Funkcje strat dla zachowania tożsamości

Trening tych systemów wymaga wyspecjalizowanych funkcji strat, które jawnie karają dryfowanie tożsamości:

Strata zachowania tożsamości:

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

Gdzie f to wstępnie trenowany koder rozpoznawania twarzy, G to generator, a v_t reprezentuje wygenerowane klatki. Pierwszy termin zapewnia, że wygenerowane twarze pasują do referencji; drugi karze zmienność od klatki do klatki.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Dopasowanie tożsamości dla każdej klatki do referencji
    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()
 
    # Spójność czasowa między sąsiednimi klatkami
    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

Scenariusze wielopostaciowe: Trudniejszy problem

Spójność jednopostaciowa jest w dużej mierze rozwiązana. Scenariusze wielopostaciowe—gdzie wiele różnych tożsamości musi być jednocześnie utrzymywane—pozostają trudne. Mechanizmy atencji mogą pomylić tożsamości, co prowadzi do wycieku cech między postaciami.

Obecne podejścia używają oddzielnych banków tożsamości:

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 separator, aby zapobiec pomyleniu
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Tokeny separatora działają jak asekuracje między wspinaczami—utrzymując odrębne tożsamości nawet w bliskiej bliskości.

Praktyczne implikacje dla twórców

Dla tych, którzy używają tych narzędzi zamiast je budować, wiele praktycznych schematów się pojawiło:

Jakość obrazu referencyjnego ma znaczenie: Wysokorozdzielczościowe, dobrze oświetlone obrazy referencyjne z neutralnymi wyrażeniami twarzy przynoszą bardziej spójne wyniki. Model uczy się tożsamości z tych zakotwiczników, a szumy się rozprzestrzeniają.

Wiele referencji poprawia robustność: Udostępnienie 3-5 obrazów referencyjnych z różnych kątów pomaga modelowi zbudować bardziej kompletną reprezentację tożsamości. Pomyśl o tym jako triangulacji pozycji z wielu punktów.

Inżynieria promptu dla spójności: Jawne opisy tożsamości w promptach wzmacniają spójność wizualną. „Trzydziestoletnia kobieta z krótką brązową włosami i zielonymi oczami" zapewnia dodatkowe ograniczenia, które model może wykorzystać.

Droga do przodu

Zbliżamy się do progu, gdzie wygenerowane przez AI wideo może utrzymywać spójność postaci wystarczającą do opowiadania narracyjnego. Pozostałe wyzwania—subtelna spójność wyrazu, generowanie długotrwałe poza 60 sekund i interakcja wielopostaciowa—są aktywnie rozwiązywane.

W Bonega.ai jesteśmy szczególnie zainteresowani tym, jak te ulepszenia spójności integrują się z możliwościami rozszerzenia wideo. Zdolność do rozszerzenia istniejącego materiału filmowego przy jednoczesnym zachowaniu doskonałej spójności postaci otwiera możliwości kreatywne, które zwyczajnie nie były wykonalne 12 miesięcy temu.

Matematyczna elegancja traktowania tożsamości jako pierwszoklasowego problemu architektonicznego, a nie post-hoc korekcji, oznacza dojrzałość w tym, jak myślimy o generowaniu wideo. Jak ustanowienie dobrze zaopatrzonego obozu wysokościowego przed pchniięciem na szczyt, te fundamentalne ulepszenia umożliwiają dłuższe, bardziej ambitne podróże kreatywne, które czekają nas w przededniu.

Spójność postaci nie jest tylko metryką techniczną—jest fundamentem wizualnego opowiadania. I w 2025 roku ten fundament wreszcie stał się wystarczająco solidny, aby na nim budować.