turbodiffusion-video

name	turbodiffusion-video
title	TurboDiffusion: Accelerating Video Diffusion 100-200x
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2512.16093
keywords	["video-generation","diffusion","acceleration","quantization","inference"]
description	Achieve 100-200× video generation speedup via algorithm-system co-optimization. Combines sparse attention acceleration (SageAttention + trainable Sparse-Linear Attention), step distillation, W8A8 quantization, and custom CUDA kernels—maintaining quality through modular optimizations that compose for cumulative gains.

Overview

TurboDiffusion addresses the prohibitive computational cost of video diffusion models through four complementary optimizations. Each technique is orthogonal and can be applied independently, enabling systems to compose them for cumulative speedups while maintaining video quality.

Core Technique

The key insight is that algorithm-level and system-level optimizations are complementary, enabling cumulative gains.

Attention Acceleration (Two Components):

# Attention acceleration combining two techniques
class AttentionAccelerator:
    def __init__(self):
        self.sage_attention = SageAttention()  # Low-bit quantization
        self.sparse_linear_attention = TrainableSLA()  # Learnable sparsity

    def forward_with_acceleration(self, q, k, v):
        """
        Apply two complementary attention optimizations.
        """
        # Component 1: SageAttention
        # Uses low-bit quantization for attention computation
        q_quantized = self.sage_attention.quantize_query(q)
        k_quantized = self.sage_attention.quantize_key(k)
        v_quantized = self.sage_attention.quantize_value(v)

        # Component 2: Trainable Sparse-Linear Attention (SLA)
        # Learn which attention connections are necessary
        sparse_mask = self.sparse_linear_attention.compute_mask(q, k)

        # Apply both optimizations
        # First reduce memory bandwidth via low-bit math
        attention_scores = torch.matmul(q_quantized, k_quantized.transpose(-1, -2))
        attention_scores = self.sage_attention.dequantize(attention_scores)

        # Then apply learned sparsity
        attention_scores = attention_scores * sparse_mask

        
        output = torch.matmul(attention_scores, v_quantized)

         output