Diffusion Transformers: สถาปัตยกรรมที่ปฏิวัติการสร้างวิดีโอในปี 2025

การปีนขึ้นสู่ยอดเขาของการสร้างวิดีโอเป็นการปีนที่มีระเบียบ แต่ละนวัตกรรมทางสถาปัตยกรรมสร้างขึ้นจากอันก่อนหน้าครับ ในปี 2025 เรามาถึงสิ่งที่รู้สึกเหมือนยอดเขาใหม่ด้วย diffusion transformers—การผสมผสานที่สง่างามที่กำลังปรับเปลี่ยนพื้นฐานวิธีที่เราคิดเกี่ยวกับการสร้างตามเวลาครับ ให้ผมแนะนำคุณผ่านภูมิทัศน์ทางเทคนิคที่ปรากฏขึ้น เหมือนการนำทางสันเขาระหว่าง Dent Blanche และ Matterhorn ครับ

การบรรจบกันทางสถาปัตยกรรม

โมเดลการสร้างวิดีโอแบบดั้งเดิมต่อสู้กับความท้าทายพื้นฐานสองประการ: การรักษาความสอดคล้องตามเวลาผ่านเฟรมและการขยายไปยังลำดับที่ยาวขึ้นครับ ความก้าวหน้ามาเมื่อนักวิจัยตระหนักว่ากรอบการทำงานความน่าจะเป็นของโมเดล diffusion สามารถเพิ่มประสิทธิภาพด้วยกลไก attention ของ transformers—สร้างสิ่งที่เราเรียกตอนนี้ว่า latent diffusion transformers ครับ

class DiffusionTransformer(nn.Module):
    def __init__(self, latent_dim=512, num_heads=16, num_layers=24):
        super().__init__()
        self.patch_embed = SpacetimePatchEmbed(latent_dim)
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(
                d_model=latent_dim,
                nhead=num_heads,
                dim_feedforward=latent_dim * 4,
                norm_first=True  # Pre-normalization สำหรับความเสถียร
            ),
            num_layers=num_layers
        )
        self.denoise_head = nn.Linear(latent_dim, latent_dim)
 
    def forward(self, x_t, timestep, conditioning=None):
        # แยก spacetime patches - นวัตกรรมที่สำคัญ
        patches = self.patch_embed(x_t)
 
        # เพิ่ม positional และ temporal embeddings
        patches = patches + self.get_pos_embed(patches.shape)
        patches = patches + self.get_time_embed(timestep)
 
        # การประมวลผล Transformer ด้วย QK-normalization
        features = self.transformer(patches)
 
        # คาดการณ์สัญญาณรบกวนสำหรับ diffusion
        return self.denoise_head(features)

ความสง่างามอยู่ที่การปฏิบัติต่อวิดีโอไม่ใช่เป็นลำดับของภาพ แต่เป็นปริมาตร spacetime ที่รวมกันครับ แนวทางของ OpenAI กับ Sora ประมวลผลวิดีโอผ่านทั้งมิติเชิงพื้นที่และเวลา สร้างสิ่งที่พวกเขาเรียกว่า "spacetime patches"—คล้ายกับวิธีที่ Vision Transformers ประมวลผลภาพ แต่ขยายไปยังมิติเวลาครับ

รากฐานทางคณิตศาสตร์: เกินกว่าการลดสัญญาณรบกวนง่ายๆ

นวัตกรรมทางคณิตศาสตร์หลักขยายการกำหนดสูตร diffusion มาตรฐานครับ แทนที่จะเป็นแนวทางแบบดั้งเดิมที่เราสร้างโมเดล p_θ(x_{t-1}|x_t) diffusion transformers ทำงานบนการแทนค่า latent ที่บีบอัด:

Loss Function: L_DT = E[||ε - ε_θ(z_t, t, c)||²]

โดยที่ z_t แสดงถึงการเข้ารหัส latent spacetime และ transformer ε_θ คาดการณ์สัญญาณรบกวนตามตำแหน่งเวลา t และการปรับสภาพทางเลือก c ครับ ความก้าวหน้าที่สำคัญคือ Query-Key normalization ทำให้กระบวนการนี้เสถียร:

Attention: Attention(Q, K, V) = softmax(Q_norm · K_norm^T / √d_k) · V

การปรับเปลี่ยนที่ดูเหมือนง่ายนี้—การปรับ Q และ K ก่อนการคำนวณ attention—ปรับปรุงความเสถียรในการฝึกอย่างมากในระดับใหญ่ ทำให้โมเดลสามารถฝึกอย่างมีประสิทธิภาพบนระบบแจกจ่ายครับ

การสร้างเสียง-ภาพหลายขั้นตอน: สถาปัตยกรรม Veo 3

Veo 3 ของ Google DeepMind แนะนำสถาปัตยกรรมหลายขั้นตอนที่ซับซ้อน—transformer 12 พันล้านพารามิเตอร์สร้างคีย์เฟรมที่ช่วงเวลา 2 วินาที ในขณะที่ U-Net 28 พันล้านพารามิเตอร์สอดแทรกเฟรมกลาง และเครื่องยนต์สังเคราะห์เสียง 9 พันล้านพารามิเตอร์แยกต่างหากผลิตเพลงประกอบที่ซิงค์กันครับ คิดเหมือนการจับทั้งความงามภาพและเสียงของหิมะถล่มผ่านระบบเฉพาะทางที่ประสานงานกันครับ

class MultiStageVideoEncoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.keyframe_generator = KeyframeTransformer()  # 12B params
        self.frame_interpolator = InterpolationUNet()    # 28B params
        self.audio_synthesizer = AudioGenerator()        # 9B params
 
    def generate(self, prompt, duration=8):
        # สร้างคีย์เฟรมก่อน
        keyframes = self.keyframe_generator(prompt, num_frames=duration//2)
 
        # สอดแทรกเฟรมกลาง
        full_video = self.frame_interpolator(keyframes)
 
        # สร้างเสียงที่ซิงค์กัน
        audio = self.audio_synthesizer(full_video, prompt)
 
        return full_video, audio

กระบวนการ diffusion สร้างทั้งสองโมดัลลิตีด้วยการซิงโครไนซ์ตามเวลา บรรลุความแม่นยำในการซิงค์ริมฝีปากน้อยกว่า 120 มิลลิวินาทีสำหรับบทสนทนาครับ

ภูมิทัศน์โมเดลปัจจุบันและประสิทธิภาพ

ความแตกต่างทางสถาปัตยกรรมระหว่างโมเดลปัจจุบันแสดงแนวทางที่แตกต่างกันในการสร้างวิดีโอ:

สิ่งที่น่าสนใจเป็นพิเศษคือวิธีที่โมเดลต่างๆ ปรับแต่งความยาวลำดับผ่านรูปแบบ attention ต่างๆ:

def hierarchical_attention(patches, hierarchy_levels=3):
    """
    การปรับแต่ง attention แบบก้าวหน้าจากหยาบไปละเอียด
    คล้ายกับการปีน: สร้างค่ายฐาน จากนั้นผลักดันไปยังยอด
    """
    attention_maps = []
 
    for level in range(hierarchy_levels):
        window_size = 2 ** (hierarchy_levels - level)
        local_attn = compute_windowed_attention(patches, window_size)
        attention_maps.append(local_attn)
 
    # รวม multi-scale attention
    return torch.stack(attention_maps).mean(dim=0)

ความก้าวหน้าสถาปัตยกรรมที่ตระหนักถึงการเคลื่อนไหว

ปี 2025 ได้เห็นการเกิดขึ้นของสถาปัตยกรรมที่ตระหนักถึงการเคลื่อนไหวที่สร้างโมเดลพลวัตตามเวลาอย่างชัดเจนครับ กรอบงาน Motion-Aware Generative (MoG) ที่เสนอโดยนักวิจัยจากมหาวิทยาลัยนานจิงและ Tencent ใช้ประโยชน์จากคำแนะนำการเคลื่อนไหวที่ชัดเจนจากโมเดลสอดแทรกที่อิงจากการไหลเพื่อเพิ่มประสิทธิภาพการสร้างวิดีโอครับ กรอบงานรวมคำแนะนำการเคลื่อนไหวทั้งใน latent และระดับคุณลักษณะ ปรับปรุงการตระหนักถึงการเคลื่อนไหวในโมเดลการสร้างวิดีโอขนาดใหญ่ที่ฝึกไว้ล่วงหน้าอย่างมากครับ

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

การปรับแต่งการผลิต: จากห้องปฏิบัติการสู่การประยุกต์ใช้

ความสำเร็จที่แท้จริงของปี 2025 ไม่ใช่แค่คุณภาพที่ดีขึ้น—แต่เป็นประสิทธิภาพการปรับใช้ครับ การปรับแต่ง TensorRT สำหรับโมเดล diffusion ที่อิงจาก transformer บรรลุการเร่งความเร็วที่สำคัญ:

# ไปป์ไลน์การสร้างมาตรฐาน
model = DiffusionTransformer().cuda()
frames = model.generate(prompt, num_frames=120)  # 5 วินาทีของวิดีโอ
 
# ไปป์ไลน์ที่ปรับแต่งด้วย TensorRT
import tensorrt as trt
optimized_model = optimize_with_tensorrt(model,
                                         batch_size=1,
                                         precision='fp16',
                                         use_flash_attention=True)
frames = optimized_model.generate(prompt, num_frames=120)  # เร็วขึ้นอย่างมาก

Parameter-Efficient Fine-Tuning ผ่าน LoRA ได้ทำให้การปรับแต่งเป็นประชาธิปไตยครับ ทีมสามารถปรับโมเดลวิดีโอที่ฝึกไว้ล่วงหน้าด้วยเพียง 1% ของพารามิเตอร์ต้นฉบับ:

class VideoLoRA(nn.Module):
    def __init__(self, base_model, rank=16):
        super().__init__()
        self.base_model = base_model
 
        # แทรกการปรับตัวแบบ low-rank
        for name, module in base_model.named_modules():
            if isinstance(module, nn.Linear):
                # ฝึกเฉพาะเมทริกซ์ขนาดเล็กเหล่านี้
                setattr(module, 'lora_A', nn.Parameter(torch.randn(rank, module.in_features)))
                setattr(module, 'lora_B', nn.Parameter(torch.randn(module.out_features, rank)))

มองไปข้างหน้า: การปีนครั้งต่อไป

การบรรจบกันสู่สถาปัตยกรรมที่รวมกันยังคงดำเนินต่อไปครับ โมเดล BAGEL ของ ByteDance (พารามิเตอร์ที่ใช้งานอยู่ 7B ด้วยสถาปัตยกรรม Mixture-of-Transformers) และโมเดล Transfusion ของ Meta เป็นผู้บุกเบิกสถาปัตยกรรม transformer เดียวที่จัดการทั้งงานแบบ autoregressive และ diffusion ครับ ที่ Bonega.ai เราตื่นเต้นเป็นพิเศษเกี่ยวกับผลกระทบสำหรับการประมวลผลวิดีโอแบบเรียลไทม์—ลองนึกภาพการยืดภาพที่มีอยู่ของคุณอย่างราบรื่นด้วยเนื้อหาที่สร้างด้วย AI ที่ตรงกันอย่างสมบูรณ์แบบในสไตล์และการเคลื่อนไหวครับ

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

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