ความสอดคล้องของตัวละครในวิดีโอ AI: โมเดลจำใบหน้าได้อย่างไร

ท้าทายที่คงอยู่มากที่สุดอย่างหนึ่งในการสร้างวิดีโอด้วย AI ก็คือการรักษาความสอดคล้องของตัวละครระหว่างฉากต่างๆ ครับ ถามผู้กำกับวิดีโอใคร: เรื่องราวจะพังพินาศในทันทีที่ใบหน้าของตัวประกอบการของคุณเปลี่ยนแปลงเล็กน้อยระหว่างการตัดต่อ ในปี 2568 เราได้เห็นโมเดลแตกปัญหานี้ด้วยนวัตกรรมด้านสถาปัตยกรรมที่สวยงามพอๆ กับเส้นทางที่วางแผนไว้อย่างดีเพื่อปีนขึ้นไปบนยอดเขาที่ยากลำบากครับ ขอให้ฉันอธิบายวิธีที่โมเดลวิดีโอสมัยใหม่กำลังเรียนรู้ที่จะจดจำใบหน้า

ความท้าทายด้านความสอดคล้อง

โมเดลการแพร่กระจายแบบดั้งเดิมสร้างเฟรมแต่ละเฟรมโดยใช้การสุ่มตัวอย่างความน่าจะเป็น ซึ่งนำเสนอความแปรปรวน—มีประโยชน์สำหรับความหลากหลาย แต่เป็นปัญหาสำหรับเอกลักษณ์ ครับ เมื่อสร้างวิดีโอ 10 วินาทีที่ 24fps โมเดลจะทำการตัดสินใจตามลำดับ 240 ครั้ง แต่ละครั้งมีโอกาสที่จะเกิดการเลื่อนไถ่

# ปัญหาหลัก: แต่ละขั้นตอนการลดเสียงรบกวนนำเสนอความแปรปรวน
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  # ความแปรปรวนเล็กน้อยสะสมมากขึ้นระหว่างเฟรม

โมเดลวิดีโอยุคแรกๆ เช่น Gen-1 และ Pika 1.0 ต่างก็มีปัญหาที่เห็นได้ชัด ตัวละครจะเปลี่ยนแปลงลักษณะ หรืออายุที่ดูเหมือนว่ามีการเปลี่ยนแปลงระหว่างฉากต่างๆ หรือพัฒนาลักษณะที่ไม่สอดคล้องกัน—สิ่งที่ผู้ปฏิบัติเรียกว่า "identity drift" ครับ ความก้าวหน้าที่สำคัญมาจากการพิจารณาความสอดคล้องของตัวละครไม่ใช่เป็นปัญหาหลังการประมวลผล แต่เป็นปัญหาสถาปัตยกรรม

การฝังข้อมูลที่รักษาเอกลักษณ์: รากฐาน

นวัตกรรมหลักแรกคือการนำเสนอการฝังข้อมูลเอกลักษณ์ที่เฉพาะเจาะจงซึ่งยังคงอยู่ตลอดกระบวนการสร้างสรรค์ ครับ แทนที่จะพึ่งพาการปรับสภาพข้อความเพียงอย่างเดียว โมเดลจึงรักษาโทเค็นเอกลักษณ์ที่ชัดเจนไว้:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # โมเดลใบหน้าที่ฝึกมาแล้ว
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # สกัดลักษณะเอกลักษณ์จากเฟรมอ้างอิง
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # ข้ามจากการสังเกตอย่างไม่นอกเหนือไปจากโทเค็นเอกลักษณ์ที่เรียนรู้
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

โทเค็นเอกลักษณ์เหล่านี้จึงถูกฉีดเข้าไปในกระบวนการแพร่กระจายในทุกขั้นตอนการลดเสียงรบกวน ซึ่งสร้างสิ่งที่ฉันชอบเรียกว่า "จุดยึด"—เหมือนการป้องกันแบบคงที่ในเส้นทางการปีนเขาที่คุณสามารถหนีบกลับมาเมื่อสภาพอากาศกลายเป็นไม่แน่นอนได้ทุกเมื่อ ครับ

ความสนใจข้ามเฟรม: การเรียนรู้เอกลักษณ์ตามเวลา

ความก้าวหน้าที่สองคือด้านสถาปัตยกรรม: โมเดลจึงอยู่ในสถานะให้ความสนใจในเฟรมต่างๆ อย่างชัดเจนเมื่อตัดสินใจเกี่ยวกับลักษณะตัวละคร ครับ Diffusion transformers สนับสนุนสิ่งนี้โดยธรรมชาติผ่านการประมวลผลแพตช์พื้นที่เวลา แต่โมเดลที่มุ่งเน้นความสอดคล้องไปไกลกว่านั้น

นวัตกรรมหลัก: ชั้นความสนใจที่รับรู้เอกลักษณ์ที่ให้ความสนใจอย่างเฉพาะเจาะจงกับบริเวณใบหน้าทั่วมิติเวลา:

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):
        # ความสนใจเชิงพื้นที่มาตรฐานภายในเฟรม
        x = self.spatial_attn(x, x, x)[0] + x
 
        # ความสนใจตามเวลาข้ามเฟรม
        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)
 
        # ความสนใจเฉพาะเอกลักษณ์โดยใช้บริเวณใบหน้า
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

กลไกความสนใจสามชั้นนี้—เชิงพื้นที่ ตามเวลา และเฉพาะเอกลักษณ์—อนุญาตให้โมเดลตัดสินใจเกี่ยวกับลักษณะภายนอกในขณะที่อ้างอิงอย่างชัดเจนทั้งเอกลักษณ์ที่สร้างขึ้นและเฟรมก่อนหน้า ครับ

เปรียบเทียบวิธีการโมเดลปัจจุบัน

แพลตฟอร์มการสร้างวิดีโอหลักต่างๆ ได้นำไปปฏิบัติความสอดคล้องของตัวละครในรูปแบบต่างๆ:

Gen-4.5 ของ Runway สมควรได้รับการกล่าวถึงพิเศษที่นี่ ครับ วิธีการของพวกเขาผสมผสานการปรับสภาพภาพอ้างอิงกับสิ่งที่พวกเขาเรียกว่า "identity locks"—โทเค็นที่เรียนรู้ว่าโมเดลได้รับการฝึกเพื่อรักษาไว้โดยไม่คำนึงถึงการตัดสินใจการสร้างสรรค์อื่นๆ ครับ ตัวเลือกสถาปัตยกรรมนี้อาจเป็นส่วนหนึ่งของสาเหตุที่พวกเขาเป็นผู้นำในการแข่งขัน Video Arena

วิธีการเฟรมอ้างอิง

การเปลี่ยนแปลงที่สำคัญในปี 2568 คือการเลื่อนไปสู่การสร้างที่ปรับสภาพตามข้อมูลอ้างอิง ครับ แทนที่จะสร้างตัวละครล้วนๆ จากคำอธิบายข้อความ โมเดลจึงยอมรับภาพอ้างอิงที่กำหนดลักษณะภายนอกตามหลัก:

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):
        # เข้ารหัสเอกลักษณ์จากภาพอ้างอิง
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # ผสมภาพอ้างอิงหลายภาพสำหรับเอกลักษณ์ที่มีความทนทาน
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # สร้างโดยใช้การปรับสภาพเอกลักษณ์
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # สมดุลระหว่างความสอดคล้องกับความคิดสร้างสรรค์
            }
        )
        return video

พารามิเตอร์ identity_strength แสดงถึงการแลกเปลี่ยนที่สำคัญ ครับ หากตั้งค่าสูงเกินไป โมเดลจึงกลายเป็นแข็งเกร็ง ไม่สามารถแสดงการเปลี่ยนแปลงการแสดงออกอย่างเป็นธรรมชาติ หากตั้งค่าต่ำเกินไป เอกลักษณ์ที่เลื่อนไถ่จึงกลับมา การหาจุดที่ดี—โดยทั่วไปประมาณ 0.7-0.85—เป็นศิลปะและวิทยาศาสตร์ผสมกัน ครับ

ฟังก์ชันการสูญเสียสำหรับการรักษาเอกลักษณ์

การฝึกระบบเหล่านี้ต้องใช้ฟังก์ชันการสูญเสียเฉพาะที่ลงโทษความล้มเหลวในการรักษาเอกลักษณ์อย่างชัดเจน:

ฟังก์ชันการสูญเสียการรักษาเอกลักษณ์:

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

โดยที่ f เป็นตัวเข้ารหัสการจดจำใบหน้าที่ฝึกมาแล้ว G เป็นตัวสร้าง และ v_t แสดงถึงเฟรมที่สร้างขึ้น ครับ พจน์แรกรับประกันว่าใบหน้าที่สร้างขึ้นตรงกับข้อมูลอ้างอิง พจน์ที่สองลงโทษความแปรปรวนระหว่างเฟรม

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # การจับคู่เอกลักษณ์ต่อเฟรมกับข้อมูลอ้างอิง
    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_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

สถานการณ์หลายตัวละคร: ปัญหาที่ยากขึ้น

ความสอดคล้องของตัวละครเดียวแก้ไขได้เป็นส่วนใหญ่ ครับ สถานการณ์หลายตัวละคร—ซึ่งต้องรักษาเอกลักษณ์ที่แตกต่างหลายตัวไว้พร้อมกัน—ยังคงท้าทายอยู่ ครับ กลไกความสนใจอาจสร้างความสับสนเอกลักษณ์ ส่งผลให้เกิดการไหลของลักษณะระหว่างตัวละคร

วิธีการปัจจุบันใช้ธนาคารเอกลักษณ์แยกต่างหาก:

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)
            # เพิ่มตัวคั่นเพื่อป้องกันความสับสน
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

โทเค็นตัวคั่นทำหน้าที่เหมือนการบ่มใจระหว่างนักปีนเขา—รักษาเอกลักษณ์ที่แตกต่างกันแม้ว่าจะทำงานในบริเวณที่ใกล้ชิดกัน ครับ

ความหมายที่ใช้ได้จริงสำหรับผู้สร้างสรรค์

สำหรับผู้ใช้เครื่องมือเหล่านี้แทนที่จะสร้างสรรค์ รูปแบบที่ใช้ได้จริงหลายแบบได้ปรากฏขึ้น ครับ

คุณภาพภาพอ้างอิงสำคัญ: ภาพอ้างอิงที่มีความละเอียดสูงและมีแสงสว่างดี โดยมีการแสดงออกเป็นกลาง ให้ผลลัพธ์ที่สอดคล้องกันมากขึ้น ครับ โมเดลเรียนรู้เอกลักษณ์จากจุดยึดเหล่านี้ และเสียงรบกวนจึงแพร่กระจายไป

ภาพอ้างอิงหลายภาพช่วยเพิ่มความทนทาน: การให้ภาพอ้างอิง 3-5 ภาพจากมุมต่างๆ ช่วยให้โมเดลสร้างการแสดงเอกลักษณ์ที่สมบูรณ์ยิ่งขึ้น ครับ คิดว่ามันเป็นการหาตำแหน่งสามเหลี่ยมจากจุดหลายจุด

วิศวกรรมข้อความแนะนำสำหรับความสอดคล้อง: คำอธิบายเอกลักษณ์ที่ชัดเจนในข้อความสนับสนุนความสอดคล้องทางภาพ ครับ "ผู้หญิงอายุ 30 ปีที่มีผมสั้นสีน้ำตาลและตาสีเขียว" ให้ข้อจำกัดเพิ่มเติมที่โมเดลสามารถใช้ประโยชน์ได้

เส้นทางข้างหน้า

เรากำลังเข้าใกล้จุดเกณฑ์ที่ AI สร้างวิดีโออาจรักษาความสอดคล้องของตัวละครไว้ได้เพียงพอสำหรับเรื่องราวการเล่าเรื่อง ครับ ความท้าทายที่เหลืออยู่—ความสอดคล้องของการแสดงออกที่ลึกลับ การสร้างระยะยาวนอกเหนือ 60 วินาที และปฏิสัมพันธ์ของตัวละครหลายตัว—กำลังได้รับการแก้ไขอย่างแข็งขัน ครับ

ที่ Bonega.ai เราสนใจเป็นพิเศษว่ากำลังปรับปรุงความสอดคล้องกับความสามารถในการขยายวิดีโอ อย่างไร ครับ ความสามารถในการขยายสินค้าที่มีอยู่พร้อมกับรักษาความสอดคล้องของตัวละครที่สมบูรณ์แบบจึงเปิดความเป็นไปได้สร้างสรรค์ที่ไม่สามารถทำได้ 12 เดือนก่อนหน้า

ความเลิศหลอมของคณิตศาสตร์ของการปฏิบัติต่อเอกลักษณ์เป็นข้อกังวลสถาปัตยกรรมชั้นแรก แทนที่จะเป็นการแก้ไขหลังการประมวลผล ทำเครื่องหมายความเป็นอุบัติวิทยาในวิธีที่เราคิดเกี่ยวกับการสร้างวิดีโอ ครับ เหมือนการสร้างค่ายสูงที่เก็บสินค้าอบรม ก่อนการผลักดันสรุป การปรับปรุงพื้นฐานเหล่านี้อนุญาตให้มีการเดินทางที่นานขึ้น และมีความทะเยอทะวายสร้างสรรค์ที่อยู่ข้างหน้า ครับ

ความสอดคล้องของตัวละครไม่ใช่เพียงตัวชี้วัดทางเทคนิก—เป็นรากฐานของการเล่าเรื่องทางภาพ ครับ และในปี 2568 รากฐานนั้นได้กลายเป็นแข็งแรงพอที่จะสร้างสิ่งต่างๆ ครับ