עקביות דמויות בווידאו AI: איך מודלים לומדים לזכור פנים

אחד האתגרים הקשים ביותר בייצור וידאו AI היה שמירה על עקביות של דמויות בין הצילומים. שאל כל במאי: סיפור קורס בדיוק כשהפנים של הגיבור הראשי משתנות זوטות בין ההפעלות. ב-2025, ראינו סוף סוף מודלים שפתרו את הבעיה הזו עם חידושים מקומיים שנראים אלגנטיים כמו מסלול מתוכנן טוב לעלייה במטפס קשה. תן לי ללכת איתך על איך מודלי וידאו מודרניים לומדים לזכור פנים.

אתגר העקביות

מודלי Diffusion מסורתיים יוצרים כל frame עם דגימה הסתברותית. זה מכניס שונות—שימושית לגיוון, בעיה לזהות. כשמייצרים וידאו של 10 שניות ב-24fps, המודל מקבל 240 החלטות ברצף, כל אחת עם הזדמנויות לסטייה.

# הבעיה הבסיסית: כל שלב Denoising מכניס שונות
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # הדגימה הזו מכניסה סטוכסטיות
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # וריאציות קטנות מצטברות על פני Frames

מודלי וידאו מוקדמים כמו Gen-1 ו-Pika 1.0 התקשו בעליל. דמויות הזיזו בהופעה, התבגרו מעט בין הצילומים, או פיתחו תכונות לא עקביות—מה שמעשיים קראו "דריפט זהות". פריצת הדרך הגיעה מהטיפול בעקביות דמויות לא כבעיית עיבוד חוקי, אלא כאחת קומתית.

Embedding שמשמרים זהות: הבסיס

החידוש הראשון הגדול היה הכנסת Embedding זהות ייעודיות שנמשכות על כל תהליך היצור. במקום להסתמך אך ורק על Text Conditioning, מודלים שומרים כעת מטוקנים זהות מפורשים:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # מודל פנים Pre-trained
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # חילוץ תכונות זהות מ-reference
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Cross-attend עם Token זהות למודים
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Token זהות אלה מוזרקים לתוך תהליך Diffusion בכל שלב Denoising, ויוצרים מה שאני אוהב לחשוב עליו כ"נקודות עוגן"—כמו הגנה קבועה במסלול טיפוס שאתה תמיד יכול להתחבר חזרה אליה כשתנאים בחוסר ודאות.

Cross-Frame Attention: למידה של זהות Temporal

פריצת הדרך השנייה הייתה קומתית: מודלים שולחים כעת במפורש Attend בין Frames כשמקבלים החלטות על הופעת דמויות. Diffusion Transformers בטבע תומכים בזה דרך עיבוד Patch Spacetime שלהם, אבל מודלים ממוקדי עקביות הולכים רחוק יותר.

חידוש מפתח: Dedicated Identity Attention Layers שבמפורש Attend לאזורי פנים על פני הממד הזמני:

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):
        # Spatial Attention סטנדרטי בתוך Frames
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Temporal Attention על פני Frames
        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)
 
        # Identity-specific Attention באמצעות אזורי פנים
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

מנגנון ה-Attention המשולש הזה—Spatial, Temporal, וזהות-ספציפי—מאפשר למודל לקבל החלטות הופעה תוך Referencing מפורש גם לזהות המוקמה וגם Frames קודמים.

השוואת גישות מודלים נוכחיות

הפלטפורמות יצור וידאו הגדולות יישמו עקביות דמויות בדרכים שונות:

Runway's Gen-4.5 ראוי לאזכור מיוחד כאן. הגישה שלהם משלבת Reference Image Conditioning עם מה שהם קוראים "זעל זהות"—Token למודים שהמודל מאומן לשמר ללא קשר להחלטות generative אחרות. הבחירה הקומתית הזו כנראה תרמה לדומיננטיות Arena הווידאו שלהם.

ה-Paradigm של Reference Frame

שינוי משמעותי ב-2025 היה התנועה לכיוון Reference-Conditioned Generation. במקום ליצור דמויות אך ורק מתיאורים Text, מודלים כעת מקבלים Reference Images שיוצרות הופעה קנונית:

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):
        # Encode זהות מ-Reference Images
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Pool Multiple References לזהות חזקה
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generate עם Identity Conditioning
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Balances עקביות vs יצירתיות
            }
        )
        return video

הפרמטר identity_strength מייצג Trade-off חשוב. יותר מדי גבוה, והמודל הופך קשיח, לא מסוגל להראות וריאציית ביטוי טבעית. יותר מדי נמוך, ודריפט חוזר. מצא את ה-Sweet Spot—בדרך כלל סביב 0.7-0.85—הוא חלק אומנות, חלק מדע.

Loss Functions לשמירת זהות

הדרכת המערכות הללו דורשת Loss Functions מיוחדות שבמפורש עונשות Drift זהות:

Identity Preservation Loss:

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

כאשר f היא Pre-trained Face Recognition Encoder, G הוא ה-Generator, ו-v_t מייצג Generated Frames. המונח הראשון מבטיח שפנים שנוצרו תואמות References; השני עונש וריאציה Frame-to-Frame.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Per-frame Identity Matching ל-Reference
    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()
 
    # Temporal Consistency בין Frames סמוכים
    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

תרחישים מרובי-דמויות: הבעיה הקשה יותר

עקביות דמות יחידה פתורה בעיקר. תרחישים מרובי-דמויות—כאשר יש לשמור על זהויות מובחנות מרובות בו זמנית—נותרים מאתגרים. מנגנוני ה-Attention יכולים לבלבל זהויות, מה שמוביל לדליפת תכונות בין דמויות.

גישות נוכחיות משתמשות בבנקי זהות נפרדים:

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)
            # Add Separator למניעת בלבול
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

ה-Token Separator פועלים כמו Belays בין טוענים—שמירה על זהויות מובחנות גם כשפועלים בקרבה הדוק.

השלכות מעשיות ליוצרים

לאלו שמשתמשים בכלים אלה במקום לבנות אותם, מספר דפוסים מעשיים עלו:

איכות Reference Image חשובה: Reference Images ברזולוציה גבוהה יותר, מוארות היטב עם ביטויים ניטרליים מייצרות תוצאות עקביות יותר. המודל לומד זהות מ-Anchor אלה, והרעש מתפשט.

Multiple References משפרים Robustness: הנחת 3-5 Reference Images מזוויות שונות עוזרת למודל לבנות ייצוג זהות מלא יותר. חשוב עליו כ-Triangulating מיקום מנקודות מרובות.

Prompt Engineering לעקביות: תיאורי זהות מפורשים ב-Prompts חוזקים עקביות חזותית. "אישה בת 30 עם שיער חום קצר וחה ירוקות" מספק אילוצים נוספים שהמודל יכול להשתמש בהם.

הדרך קדימה

אנחנו מתקרבים לסף כאשר וידאו AI-שנוצר יכול לשמור על עקביות דמויות מספיקה לסיפור נרטיבי. האתגרים שנותרו—עקביות ביטוי זוטה, יצור ארוך-טווח מעבר ל-60 שניות, וייעוץ מרובי-דמויות—מטופלים באופן פעיל.

ב-Bonega.ai, אנחנו במיוחד מעוניינים איך שיפורי עקביות אלה משתלבים עם יכולות הרחבה וידאו. היכולת להרחיב Footage קיים תוך שמירה על עקביות דמויות מושלמת פותחת אפשרויות יצירתיות שפשוט לא היו כדאיות 12 חודשים לפני כן.

האלגנציה המתמטית של עיסוק בזהות כחששה קומתית ראשונה, במקום תיקון Post-Hoc, מסמנת Maturation בכיצד אנחנו חושבים על יצור וידאו. כמו הקמת High Camp מאובזר היטב לפני דחיפה לפסגה, שיפורים בסיסיים אלה מאפשרים את הנסיעות היצירתיות הארוכות והשאפתניות יותר שמוטלות קדימה.

עקביות דמויות היא לא רק Metric טכני—היא הבסיס של Storytelling ויזואלי. וב-2025, הבסיס הזה סוף סוף הפך מוצק מספיק לבנות עליו.