{"slug": "vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus", "title": "VSA: Accelerating Video Diffusion Inference with Sparse Attention on AMD GPUs", "summary": "AMD introduced VSA (Video Sparse Attention), a hardware-efficient sparse attention mechanism implemented with CK Tile, achieving a 3.31× attention kernel-time speedup at 70% sparsity over FlashAttention on AMD Instinct MI308X GPUs for video diffusion inference. Developed by researchers from UC San Diego, MBZUAI, and UC Berkeley, VSA uses a two-stage coarse-to-fine attention approach with 3D space-filling curve token reordering to reduce computation while preserving visual quality.", "body_md": "# VSA: Accelerating Video Diffusion Inference with Sparse Attention on AMD GPUs[#](#vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus)\n\nVideo generation powered by diffusion transformers has achieved remarkable quality, but the computational cost of attention mechanisms remains a critical bottleneck. With sequence lengths reaching tens of thousands of tokens in video generation tasks, the quadratic complexity of standard attention becomes prohibitively expensive.\n\nThis blog introduces ** VSA (Video Sparse Attention)** implemented with CK Tile, a hardware-efficient sparse attention mechanism that significantly accelerates video diffusion inference. We demonstrate how VSA, implemented through AMD’s CK Tile library, delivers significant speedups across various sparsity levels, achieving a\n\n**3.31× attention kernel-time speedup** at 70% sparsity over FlashAttention on AMD Instinct™ MI308X GPUs, with qualitative visual checks included as a sanity check.\n\n*Results may vary based on model, prompt, resolution, frame count, sequence length, sparsity level, inference settings, software versions, system configuration, and other factors.*\n\n## The Attention Bottleneck in Video Diffusion[#](#the-attention-bottleneck-in-video-diffusion)\n\nModern video diffusion models like [Wan2.1](https://github.com/Wan-Video/Wan2.1), [HunyuanVideo](https://github.com/Tencent/HunyuanVideo), and [CogVideoX](https://github.com/THUDM/CogVideo) rely on transformer architectures where attention dominates both compute and memory costs. For a typical video generation task:\n\nParameter |\nTypical Value |\n|---|---|\n|\n832 × 480 |\n|\n81 |\n|\n32,768 tokens |\n|\nO(N²) = ~1 billion operations per layer |\n\nThe standard scaled dot-product attention (SDPA) formula is:\n\n```\n\\[\\text{Attention}(Q, K, V) = \\text{Softmax}\\left(\\frac{QK^T}{\\sqrt{d_k}}\\right) V\\]\n```\n\nWhile FlashAttention optimizes memory access patterns, it still computes attention over all token pairs. However, research has shown that **most attention mass concentrates in a small subset of positions**—a property that sparse attention methods exploit to reduce computation.\n\n## VSA: Video Sparse Attention[#](#vsa-video-sparse-attention)\n\n[VSA (Video Sparse Attention)](https://arxiv.org/abs/2505.13389) is a hardware-efficient sparse attention mechanism designed specifically for video diffusion transformers. Developed by researchers from UC San Diego, MBZUAI, and UC Berkeley, VSA introduces a **two-stage coarse-to-fine attention** approach that dramatically reduces computation during inference by focusing token-level attention on selected spatial-temporal regions.\n\n### Core Principles[#](#core-principles)\n\nVSA is built on three key insights:\n\n**Attention Sparsity**: In video diffusion, attention patterns exhibit strong spatial-temporal locality. Tokens primarily attend to nearby frames and spatial regions, making full attention wasteful.**Hardware Alignment**: Sparse patterns must align with GPU tile sizes to achieve actual wall-clock speedups, not just theoretical FLOP reductions.**Adaptive Selection**: VSA dynamically selects which blocks to attend to based on the attention patterns, adapting to the specific characteristics of video data.\n\n### Two-Stage Architecture[#](#two-stage-architecture)\n\nVSA implements a two-stage coarse-to-fine selection mechanism. The goal is to avoid computing full attention over all video tokens while still preserving the most important spatial-temporal regions. The end-to-end data flow is summarized in the figure below.\n\n**Pre-stage: 3D Space-Filling Curve (SFC) Token Reordering**\n\nBefore any attention computation, video tokens are reordered using a **3D space-filling curve (SFC)**—a technique adopted from [Jenga](https://arxiv.org/abs/2505.16864). In native linear layout (T, H, W), tokens that are spatially adjacent in 3D but far apart in the flattened 1D sequence can end up in different attention blocks, breaking spatial locality. SFC reordering remaps token positions so that tokens close together in 3D space are also close together in the 1D sequence. This ensures that when the sequence is partitioned into fixed-size blocks for the attention kernel, each block corresponds to a contiguous spatial-temporal region of the video—which is the prerequisite for block-sparse patterns to be meaningful.\n\n**Stage 1: Coarse Selection**\n\nAfter SFC reordering, VSA groups neighboring video tokens into spatial-temporal cubes. In the VSA paper, a typical setting is `(Ct, Ch, Cw) = (4, 4, 4)`\n\n, so each cube contains 64 tokens. Each cube is mean-pooled into one cube-level representation, producing cube-level `Qc`\n\n, `Kc`\n\n, and `Vc`\n\n.\n\nThe coarse stage then computes cube-to-cube attention scores. For each query cube, VSA selects the Top-K key/value cubes with the highest scores. These selected cube IDs define the block-sparse attention pattern used by the fine stage.\n\nConceptually, each selected cube-level entry expands into a `B x B`\n\nblock in the full attention mask. In practice, VSA does not materialize this full-resolution mask. Instead, it passes the selected block indices directly to the fine-grained attention kernel.\n\n**Stage 2: Fine Computation**\n\nThe fine stage performs normal token-level attention, but only over the K/V cubes selected by the coarse stage. Unselected cubes are skipped entirely, reducing both memory traffic and attention computation while keeping the work aligned with block-sparse GPU kernels.\n\nThe final VSA output combines the coarse-stage output and the fine-stage output through learnable gates. This keeps global context from the coarse stage while using sparse token-level attention for the most important regions.\n\n### Block-Sparse Encoding[#](#block-sparse-encoding)\n\nVSA implements block-level sparse encoding that aligns with GPU execution characteristics:\n\n```\nVSA Sparse Structure:\n+-- lut_ptr           # Block index lookup table\n+-- valid_block_num   # Number of valid blocks per query row\n+-- kv_block_idx      # K/V block indices for each query block\n```\n\nThis block encoding format allows the kernel to skip irrelevant blocks entirely. Unlike a full 0/1 block mask, VSA stores only selected K/V block indices plus the number of valid blocks for each query block.\n\n## CK Tile Implementation[#](#ck-tile-implementation)\n\nWe provide high-performance implementations of VSA optimized for AMD Instinct GPUs in AMD’s [Composable Kernel (CK) Tile](https://github.com/ROCm/composable_kernel) library.\n\n### Key Components[#](#key-components)\n\nComponent |\nFile Path |\n|---|---|\n|\n|\n|\n|\n|\n|\n|\n|\n\n### Kernel Architecture[#](#kernel-architecture)\n\nThe CK Tile VSA kernel implements a three-stage pipeline with double buffering, enabling asynchronous overlap of computation and memory access:\n\n**Stage 1: QK GEMM + Softmax Statistics**\n\n```\nQ tiles × K tiles → attention scores\nCompute running max (M) and sum (L) for online softmax\n```\n\n**Stage 2: Softmax + Post-ops**\n\n```\nApply softmax normalization using M and L\n```\n\n**Stage 3: KV GEMM**\n\n```\nSoftmax output × V tiles → attention output\nAccumulate with previous tiles\n```\n\n### Sparse Traversal[#](#sparse-traversal)\n\nUnlike dense attention that iterates over all K/V blocks, VSA uses the LUT to jump directly to relevant blocks:\n\n```\n// Pseudo-code for VSA kernel traversal\nfor (int i = 0; i < valid_block_num[query_block]; i++) {\n    int kv_block = kv_block_idx[query_block][i];\n    // Load K/V tiles from kv_block\n    // Compute attention for this block pair\n}\n```\n\nThis eliminates wasted computation on blocks that would contribute negligible attention weight.\n\n## Comparison with Jenga[#](#comparison-with-jenga)\n\n[Jenga](https://arxiv.org/abs/2505.16864) is another recent work targeting efficient video diffusion inference, and its CK Tile implementation shares the same block-sparse attention infrastructure as VSA. However, VSA and Jenga differ substantially in their **algorithmic design**, **sparse pattern selection strategy**, and **system-level scope**—not just in their kernel encoding format.\n\n### Algorithmic Design[#](#algorithmic-design)\n\n**VSA** is a **single-component sparse attention** method. Its two stages (coarse and fine) both operate within the attention module of each transformer layer: the coarse stage selects which K/V cubes matter for each query, and the fine stage computes token-level attention only over those cubes. The final output is a learnable gate of the two stages.\n\n**Jenga** is a **two-component inference pipeline**:\n\n**AttenCarve**(within-step sparse attention): Jenga first reorders tokens using a** 3D space-filling curve (SFC)**so that spatially adjacent video tokens are also adjacent in the 1D flattened sequence, then partitions them into M uniform blocks. The sparse block selection is the union of**three masks**:** Importance Mask (B_top)**: data-dependent; uses block-level mean Q/K scores (similar in spirit to VSA’s coarse stage) to select Top-K relevant K/V blocks per query block.**Condition Mask (B_cond)**: pre-computed; attends to text condition tokens to preserve cross-modal alignment.** Adjacency Mask (B_adja)**: pre-computed; attends to spatially adjacent blocks to maintain local spatial coherence.\n\n**ProRes**(cross-step resolution scheduling): early denoising steps run on** low-resolution latents**(fewer tokens); resolution is gradually increased to the target as denoising progresses. This reduces quadratic attention cost at the pipeline level, independently of AttenCarve.\n\n### Sparse Encoding in CK Tile[#](#sparse-encoding-in-ck-tile)\n\nWhen both methods are implemented as CK Tile kernels, the difference in how they store the sparse pattern becomes concrete:\n\n**VSA** stores only the*selected*K/V block indices plus a valid-count per query block (compact index list / LUT). The kernel jumps directly to active blocks.**Jenga** stores the full M×M one-hot block relation matrix**B** and skips cells where B[i][j]=0 during traversal.\n\nVSA’s encoding is more compact when sparsity is high; Jenga’s encoding naturally represents the union of its three heterogeneous masks (Importance ∪ Condition ∪ Adjacency) without converting to a list.\n\n### Side-by-Side Summary[#](#side-by-side-summary)\n\nDimension |\nVSA |\nJenga |\n|---|---|---|\n|\nSingle Top-K from coarse cube-level attention |\nUnion of 3 masks: data-driven Top-K + forced text-condition + forced adjacency |\n|\n|\n3D Space-Filling Curve (SFC) reordering → uniform blocks |\n|\nWithin-step attention only |\nWithin-step (AttenCarve) + cross-step resolution (ProRes) + timestep skip |\n|\nYes (learnable gate between coarse and fine) |\nNo (training-free, plug-and-play) |\n|\nCaptured implicitly by cube structure |\nExplicit Adjacency Mask enforces local block attention |\n|\nNot separately handled |\nExplicit Condition Mask preserves text-token attention |\n|\nCompact index list + valid count (LUT) |\nFull M×M one-hot block relation matrix |\n|\n3.31× attention kernel vs FlashAttention (measured by AMD, see |\n8.83× end-to-end on VBench (0.01% quality drop), as reported by the Jenga authors |\n\nNote on speedup numbers: the two figures measure different things. VSA’s 3.31× is a kernel-level timing comparison against FlashAttention at a fixed 70% sparsity. Jenga’s 8.83× is an end-to-end pipeline speedup that includes both AttenCarve and ProRes (reduced token count from lower resolution). A direct apples-to-apples comparison would require running both on the same model under the same conditions. The Jenga figures in this section, including the 8.83× speedup and the accompanying quality result, are those reported in the Jenga paper ([arXiv:2505.16864]); AMD has not independently reproduced or verified them. The descriptions of Jenga’s design in the table above are likewise drawn from that paper.\n\nIn our CK Tile implementation, both methods actually share the **3D SFC token reordering** step upstream. The key difference lies in what happens after reordering: VSA uses a Top-K coarse attention score to build a compact LUT, while Jenga builds a full M×M block relation matrix from its three-mask union. The choice of kernel then follows naturally from the encoding: the VSA CK Tile kernel consumes the compact LUT, while the Jenga CK Tile kernel consumes the full block matrix.\n\n## Qualitative Visual Check[#](#qualitative-visual-check)\n\nWe generated videos using the same prompt (“Two anthropomorphic cats in comfy boxing gear and bright gloves fight intensely on a spotlighted stage.”) and the same random seed with dense FlashAttention and CK VSA Sparse Attention. The purpose of this check is to confirm that the sparse attention path does not introduce obvious visual artifacts in this sample.\n\n### Visual Comparison[#](#visual-comparison)\n\nFlash Attention (Dense, ~60.8 ms) |\nCK VSA Sparse (Sparse, ~25 ms avg) |\n|---|---|\n\n### Quality Notes[#](#quality-notes)\n\nImplementation |\nObservation |\nNotes |\n|---|---|---|\n|\nDense baseline |\nComputes all token pairs |\n|\nVisually close to baseline in this sample |\nNo obvious artifacts observed in the sampled frames |\n\nThis is a qualitative sanity check rather than a full video-generation quality benchmark. We have not yet included quantitative metrics such as VBench in this post. A VBench-style evaluation would be useful future work to measure detail preservation, temporal consistency, and semantic alignment more rigorously.\n\n## Performance Benchmarks[#](#performance-benchmarks)\n\nWe benchmarked CK VSA Sparse Attention against dense FlashAttention on a text-to-video generation task using the **Wan2.1-T2V-1.3B** model (832x480, 81 frames, 50 inference steps, BF16) on a single **AMD Instinct™ MI308X** GPU. Each attention call operates on Q/K/V of shape `[1, 12, 32768, 128]`\n\nwith a `128 x 128`\n\nblock size. Detailed tensor specifications and the per-step sparsity distribution observed during inference are listed in the [Appendix: Detailed Benchmark Configuration](#appendix-detailed-benchmark-configuration).\n\n### Headline Result: Kernel Time by Sparsity Level[#](#headline-result-kernel-time-by-sparsity-level)\n\nThe figure below is the headline comparison: CK VSA Sparse Attention versus dense FlashAttention at varying sparsity levels. Higher sparsity means fewer K/V blocks are selected by VSA, which directly translates into shorter attention kernel time. FlashAttention is essentially constant (~60.8 ms) because it computes dense attention regardless of the sparse pattern, while CK VSA’s runtime decreases as sparsity increases, reaching a **3.31×** kernel-time speedup at 70% sparsity.\n\n### End-to-End Impact[#](#end-to-end-impact)\n\nAggregated over the full 50-step inference using the sparsity distribution actually observed during generation (see [Sparsity Distribution During Inference](#sparsity-distribution-during-inference) below), the kernel-time gains translate into roughly **~37% lower end-to-end generation time** (about **3 min** with VSA versus **~4 min 47 s** with FlashAttention) on this configuration.\n\nThe kernel timings above assume the selected block indices are already available to the sparse kernel. In a full deployment, the coarse-stage selection and LUT generation must also be accounted for; that overhead is designed to be lightweight and is amortized by the savings in the fine stage, but it should still be measured in any production evaluation.\n\n## Summary[#](#summary)\n\nWe presented a CK Tile implementation of Video Sparse Attention (VSA) for video diffusion inference on AMD Instinct GPUs. On Wan2.1-T2V-1.3B at 32,768 tokens per attention call, CK VSA delivers up to **3.31×** kernel-time speedup over dense FlashAttention at 70% sparsity, and roughly **37%** lower end-to-end generation time on MI308X. We also compared the CK VSA index-list encoding with the existing CK Jenga block-mask encoding to clarify when each representation is preferable. As video diffusion models grow in resolution and length, hardware-aligned block-sparse attention such as VSA becomes increasingly important for practical deployment; a quantitative quality study (e.g., VBench) on top of these results is left as future work. For the full benchmark setup and the per-step sparsity distribution, please see the [Appendix: Detailed Benchmark Configuration](#appendix-detailed-benchmark-configuration).\n\n*Results may vary based on model, prompt, resolution, frame count, sequence length, sparsity level, inference settings, software versions, system configuration, and other factors.*\n\n## Appendix - Detailed Benchmark Configuration[#](#appendix-detailed-benchmark-configuration)\n\nThe main text uses a single condensed configuration paragraph. The full set of parameters and the per-step sparsity behavior are listed here for reproducibility.\n\n### Test Configuration[#](#test-configuration)\n\nParameter |\nValue |\n|---|---|\n|\nAMD Instinct™ MI308X GPU |\n|\nWan2.1-T2V-1.3B |\n|\nText-to-Video Generation |\n|\n832 × 480 |\n|\n81 |\n|\n50 |\n|\nBF16 |\n\n### Tensor Specifications[#](#tensor-specifications)\n\nParameter |\nValue |\n|---|---|\n|\n|\n|\n1 |\n|\n12 |\n|\n32,768 tokens |\n|\n128 |\n|\n128 × 128 |\n|\n|\n|\n~55-60 |\n\nNote:the`(Ct, Ch, Cw) = (4, 4, 4)`\n\ncubes mentioned in the VSA algorithm are used for the coarse Top-K selection; the`128 × 128`\n\nblock size above refers to the GPU tile granularity at which the fine-stage CK Tile kernel iterates over the selected K/V cubes.\n\n### Sparsity Distribution During Inference[#](#sparsity-distribution-during-inference)\n\nSparsity is not constant across diffusion steps. Early diffusion steps select more K/V blocks (lower sparsity), while late steps become more selective (higher sparsity). The distribution we observed on this workload is shown below.\n\nCombining this distribution with the per-sparsity kernel times in the main text gives a weighted-average attention kernel time of roughly **~25 ms** per call for CK VSA versus ~60.8 ms for FlashAttention, which is the basis for the end-to-end speedup quoted above.\n\n### When CK VSA Sparse Attention Helps Most[#](#when-ck-vsa-sparse-attention-helps-most)\n\nSparsity range |\nObserved speedup vs FlashAttention |\nPractical guidance |\n|---|---|---|\n< 40% |\n~1.6× |\nMarginal; dense FlashAttention is a reasonable fallback |\n40-60% |\n~1.9× – 2.8× |\nCK VSA recommended |\n> 60% |\n> 2.8× |\nCK VSA strongly recommended |\n\n## Integration Guide[#](#integration-guide)\n\n### Prerequisites[#](#prerequisites)\n\n**GPU**: AMD Instinct™ MI308X or other ROCm-compatible GPU** ROCm**: 6.3+** PyTorch**: 2.3+** CK Tile**: Latest from[composable_kernel](https://github.com/ROCm/composable_kernel)\n\n### Using VSA with CK Tile[#](#using-vsa-with-ck-tile)\n\nThe VSA implementation is available through the [AITER](https://github.com/ROCm/aiter) Python bindings, which wrap the CK Tile C++ kernels. Note that CK VSA and CK Jenga share the same sparse-attention dispatcher module in AITER, which is why the import path is named after `jenga_sparse_attention`\n\n; the underlying VSA kernel is still the index-list / LUT-based implementation described above.\n\n``` python\nfrom aiter.ops.jenga_sparse_attention import vsa_sparse_attention\n\n# Prepare inputs\nTQ = torch.randn(batch, heads, seq_len, head_dim, dtype=torch.bfloat16, device=\"cuda\")\nTK = torch.randn(batch, heads, seq_len, head_dim, dtype=torch.bfloat16, device=\"cuda\")\nTV = torch.randn(batch, heads, seq_len, head_dim, dtype=torch.bfloat16, device=\"cuda\")\n\n# Prepare LUT from Top-K selection\nTkv_block_idx = ...  # [batch, heads, num_q_blocks, max_kv_blocks] block indices\nTkv_blocks = ...     # [batch, heads, num_q_blocks] valid block count per query\n\n# Allocate output\nout = torch.zeros_like(TQ)\n\n# Compute VSA sparse attention\noutput = vsa_sparse_attention(\n    TQ, TK, TV,\n    Tkv_block_idx,    # LUT: K/V block indices for each Q block\n    Tkv_blocks,       # Number of valid K/V blocks per query block\n    out,\n    batch=batch, nhead=heads, nhead_k=heads,\n    seqlen_q=seq_len, seqlen_k=seq_len,\n    hdim_q=head_dim, hdim_v=head_dim\n)\n```\n\n**Key Input Parameters**:\n\nParameter |\nShape |\nDescription |\n|---|---|---|\n|\n|\nQuery, Key, Value tensors (BF16) |\n|\n|\nLUT storing K/V block indices for each Q block |\n|\n|\nNumber of valid K/V blocks to compute per query block |\n\n**CK Tile Source Code**:\n\nComponent |\nFile Path |\n|---|---|\nVSA Kernel Example |\n|\nDispatch Logic |\n|\nVSA Kernel |\n|\nVSA Pipeline |\n|\n\n### Generating Sparsity Patterns[#](#generating-sparsity-patterns)\n\nVSA requires upstream sparsity selection to generate the LUT. These can be:\n\n**Heuristic-based**: Use spatial-temporal locality to determine block importance** Profile-based**: Analyze attention patterns from sample runs to derive sparsity masks** Dynamic**: Compute coarse attention scores at runtime for selection\n\nNote:The following is illustrative pseudocode.`pool_to_blocks`\n\nis a placeholder for the actual cube-level mean-pool used by VSA; see the VSA paper for the production implementation.\n\n``` python\ndef generate_sparsity_lut(query, key, block_size, top_k_ratio):\n    \"\"\"Generate LUT using coarse attention scores.\"\"\"\n    # Pool tokens into blocks\n    q_blocks = pool_to_blocks(query, block_size)\n    k_blocks = pool_to_blocks(key, block_size)\n\n    # Compute coarse attention\n    coarse_scores = torch.einsum('bhqd,bhkd->bhqk', q_blocks, k_blocks)\n\n    # Top-K selection per query block\n    top_k = int(coarse_scores.shape[-1] * top_k_ratio)\n    _, lut = torch.topk(coarse_scores, top_k, dim=-1)\n\n    return lut, top_k\n```\n\n## Acknowledgements[#](#acknowledgements)\n\nThe authors would like to thank the AMD CK Tile and AITER teams for their support in developing and optimizing the sparse attention kernels on AMD Instinct GPUs. We also thank the original VSA authors from UC San Diego, MBZUAI, and UC Berkeley for open-sourcing their work and making this collaboration possible.\n\n## Additional Resources[#](#additional-resources)\n\n## Disclaimers[#](#disclaimers)\n\nThe information presented in this document is for informational purposes only and may contain technical inaccuracies, omissions, and typographical errors. The information contained herein is subject to change and may be rendered inaccurate for many reasons, including but not limited to product and roadmap changes, component and motherboard version changes, new model and/or product releases, product differences between differing manufacturers, software changes, BIOS flashes, firmware upgrades, or the like. Any computer system has risks of security vulnerabilities that cannot be completely prevented or mitigated. AMD assumes no obligation to update or otherwise correct or revise this information. However, AMD reserves the right to revise this information and to make changes from time to time to the content hereof without obligation of AMD to notify any person of such revisions or changes.\n\nTHIS INFORMATION IS PROVIDED “AS IS.” AMD MAKES NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE CONTENTS HEREOF AND ASSUMES NO RESPONSIBILITY FOR ANY INACCURACIES, ERRORS, OR OMISSIONS THAT MAY APPEAR IN THIS INFORMATION. AMD SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT WILL AMD BE LIABLE TO ANY PERSON FOR ANY RELIANCE, DIRECT, INDIRECT, SPECIAL, OR OTHER CONSEQUENTIAL DAMAGES ARISING FROM THE USE OF ANY INFORMATION CONTAINED HEREIN, EVEN IF AMD IS EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\nThird-party content is licensed to you directly by the third party that owns the content and is not licensed to you by AMD. ALL LINKED THIRD-PARTY CONTENT IS PROVIDED “AS IS” WITHOUT A WARRANTY OF ANY KIND. USE OF SUCH THIRD-PARTY CONTENT IS DONE AT YOUR SOLE DISCRETION AND UNDER NO CIRCUMSTANCES WILL AMD BE LIABLE TO YOU FOR ANY THIRD-PARTY CONTENT. YOU ASSUME ALL RISK AND ARE SOLELY RESPONSIBLE FOR ANY DAMAGES THAT MAY ARISE FROM YOUR USE OF THIRD-PARTY CONTENT.\n\nAMD, the AMD Arrow logo, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective companies.\n\n© 2026 Advanced Micro Devices, Inc. All rights reserved.", "url": "https://wpnews.pro/news/vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus", "canonical_source": "https://rocm.blogs.amd.com/artificial-intelligence/vsa-sparse-attention/README.html", "published_at": "2026-08-04 00:00:00+00:00", "updated_at": "2026-08-04 19:25:27.462060+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "generative-ai", "ai-infrastructure"], "entities": ["AMD", "VSA", "CK Tile", "FlashAttention", "AMD Instinct MI308X", "UC San Diego", "MBZUAI", "UC Berkeley"], "alternates": {"html": "https://wpnews.pro/news/vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus", "markdown": "https://wpnews.pro/news/vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus.md", "text": "https://wpnews.pro/news/vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus.txt", "jsonld": "https://wpnews.pro/news/vsa-accelerating-video-diffusion-inference-with-sparse-attention-on-amd-gpus.jsonld"}}