Format EVS helper and add SPDX header

Signed-off-by: zitian.zhao <[email protected]>

Author: skyloevil

test_evs_fix.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 """Simple harness to reason about EVS placeholder offsets.
 
 The real implementation in ``iter_mm_grid_hw`` now relies on the
@@ -10,8 +12,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Iterable
 
 import torch
 
@@ -71,21 +73,26 @@ def extract_frame_offsets(
             f"Expected {expected_frames} frame segments, got {len(segments)}"
         )
 
-    offsets = [offset_start + int(segment[0].item()) for segment in segments[:expected_frames]]
+    offsets = [
+        offset_start + int(segment[0].item()) for segment in segments[:expected_frames]
+    ]
     lengths = [int(segment.numel()) for segment in segments[:expected_frames]]
     return offsets, lengths
 
 
 def test_sparse_distribution() -> None:
     print("\n=== 测试场景 1: 稀疏分布 (真实 EVS 行为) ===")
     per_frame = [50176, 15000, 12000, 10000, 8000, 145668, 5000, 5000]
-    cfg = MaskSimulationConfig(tokens_per_frame=per_frame, prefix_tokens=3, suffix_tokens=2)
+    cfg = MaskSimulationConfig(
+        tokens_per_frame=per_frame, prefix_tokens=3, suffix_tokens=2
+    )
     mask = build_is_embed_mask(cfg)
     offsets, lengths = extract_frame_offsets(128, mask, len(per_frame))
 
     for idx, (off, size, expected) in enumerate(zip(offsets, lengths, per_frame), 1):
         print(
-            f"Frame {idx:02d}: offset={off:6d}, retained={size:6d} tokens (expected {expected})"
+            f"Frame {idx:02d}: offset={off:6d}, retained={size:6d} tokens "
+            f"(expected {expected})"
         )
         assert size == expected
 
@@ -95,7 +102,9 @@ def test_sparse_distribution() -> None:
 def test_uniform_distribution() -> None:
     print("\n=== 测试场景 2: 均匀分布 (处理器当前实现) ===")
     per_frame = [784 for _ in range(4)]
-    cfg = MaskSimulationConfig(tokens_per_frame=per_frame, prefix_tokens=2, suffix_tokens=1)
+    cfg = MaskSimulationConfig(
+        tokens_per_frame=per_frame, prefix_tokens=2, suffix_tokens=1
+    )
     mask = build_is_embed_mask(cfg)
     offsets, lengths = extract_frame_offsets(42, mask, len(per_frame))
 
@@ -109,9 +118,7 @@ def test_uniform_distribution() -> None:
     for idx, (off, size, expected_offset) in enumerate(
         zip(offsets, lengths, expected_offsets), 1
     ):
-        print(
-            f"Frame {idx:02d}: offset={off:5d}, retained={size:4d} tokens"
-        )
+        print(f"Frame {idx:02d}: offset={off:5d}, retained={size:4d} tokens")
         assert size == per_frame[idx - 1]
         assert off == expected_offset
 

vllm/model_executor/models/qwen3_vl.py

@@ -1276,7 +1276,7 @@ def __init__(self, *, vllm_config: VllmConfig, prefix: str = "model"):
         if self.is_multimodal_pruning_enabled:
             logger.debug(
                 "EVS (Efficient Video Sampling) enabled with pruning_rate=%.2f",
-                self.video_pruning_rate
+                self.video_pruning_rate,
             )
         if not multimodal_config.get_limit_per_prompt(
             "image"
@@ -1527,9 +1527,7 @@ def _postprocess_video_embeds_evs(
             second_per_grid_ts = torch.ones(len(grid_thw_list), dtype=torch.long)
         else:
             second_per_grid_ts = second_per_grid_ts.long()
-        tokens_per_second = getattr(
-            self.config.vision_config, "tokens_per_second", 1.0
-        )
+        tokens_per_second = getattr(self.config.vision_config, "tokens_per_second", 1.0)
 
         video_embeds_out = []
         for emb, size, video_second_per_grid_t in zip(
@@ -1549,9 +1547,11 @@ def _postprocess_video_embeds_evs(
                 "pruning_rate=%.2f, reduction=%.1f%%)",
                 emb.shape[0],
                 retention_mask.sum().item(),
-                size[0], size[1], size[2],
+                size[0],
+                size[1],
+                size[2],
                 self.video_pruning_rate,
-                (1 - retention_mask.float().mean().item()) * 100
+                (1 - retention_mask.float().mean().item()) * 100,
             )
 
             positions = compute_mrope_for_media(
@@ -1618,7 +1618,7 @@ def iter_mm_grid_hw(
 
                 # Check if EVS (Efficient Video Sampling) is enabled
                 is_evs_enabled = (
-                    hasattr(self, 'video_pruning_rate')
+                    hasattr(self, "video_pruning_rate")
                     and self.video_pruning_rate is not None
                     and self.video_pruning_rate > 0.0
                 )
@@ -1635,12 +1635,12 @@ def iter_mm_grid_hw(
                     # Fallback: distribute offsets uniformly when mask is missing
                     tokens_per_frame_original = llm_grid_h * llm_grid_w
                     total_retained_tokens = compute_retained_tokens_count(
-                        tokens_per_frame_original,
-                        t,
-                        self.video_pruning_rate
+                        tokens_per_frame_original, t, self.video_pruning_rate
                     )
                     tokens_per_frame = (
-                        total_retained_tokens // t if t > 0 else tokens_per_frame_original
+                        total_retained_tokens // t
+                        if t > 0
+                        else tokens_per_frame_original
                     )
                     for _ in range(t):
                         yield offset, llm_grid_h, llm_grid_w
@@ -1682,7 +1682,9 @@ def _extract_frame_offsets_from_mask(
             if split_points.numel() == 0:
                 segments = [true_indices]
             else:
-                segments = torch.tensor_split(true_indices, split_points.add(1).tolist())
+                segments = torch.tensor_split(
+                    true_indices, split_points.add(1).tolist()
+                )
 
         if len(segments) < expected_frames:
             logger.debug(