Ascend NPU support: device-aware cache release, GIL-friendly idle wait, <=8-D vision processing, BICUBIC declaration

Ascend NPU (910B, CANN 9.0.0) support for the realtime checkpoint.
CUDA behavior unchanged — every NPU path is guarded.

- modeling_moss_vl.py
- empty_cache: release NPU HBM after realtime sessions (torch_npu import
guarded; the CUDA branch is unchanged)
- realtime idle wait: a bare `while True: continue` busy-spin monopolizes
the CPython GIL and starves co-resident threads (measured: an in-process
ASR decode inflates ~150ms -> 40-80s while a session idles in
<|silence|>). Replaced with a 20ms sleep poll. Platform-neutral — CUDA
deployments embedding this checkpoint benefit equally.
- processing / video_processing: the 10-D vision permute+reshape is routed
through CPU on NPU (NPU ops support at most 8-D tensors); CUDA keeps the
on-device path untouched.
- preprocessor_config.json: declare interpolation=BICUBIC explicitly (NPU has
no implicit resize kernel; explicit declaration keeps CUDA outputs
identical — pixel_values verified bitwise-equal on identical inputs,
including forced-resize cases).

Verified on 910B2C x8 with the realtime demo (ASR/TTS/VLM E2E green); the
GIL fix restores in-process ASR latency from 52.5s to ~150ms.

modeling_moss_vl.py

@@ -2874,8 +2874,13 @@ class MossVLForConditionalGeneration(MossVLPreTrainedModel, GenerationMixin):
 
     def stop_real_time_generate(self):
         gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
+        try:
+            import torch_npu  # noqa: F401
+            if torch.npu.is_available():
+                torch.npu.empty_cache()
+        except ImportError:
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
         self.continue_generating = False
 
     @staticmethod
@@ -3099,8 +3104,11 @@ class MossVLForConditionalGeneration(MossVLPreTrainedModel, GenerationMixin):
                     break
 
             if self.continue_generating and should_wait_for_new_input and not frames_to_process and not prompts_to_process:
-                # Busy-wait — matches VideoMllama reference. Caller controls cadence via
-                # `max_tokens_per_turn` sleeping in `_real_time_sample`.
+                # GIL-friendly wait: a bare `continue` busy-spin monopolizes the GIL
+                # and starves in-process siblings (in-process ASR decode inflates
+                # ~150ms -> 40-80s while a realtime session idles in <|silence|>).
+                # 20ms poll keeps input-detection latency negligible.
+                time.sleep(0.02)
                 continue
             break
 

preprocessor_config.json

@@ -22,5 +22,6 @@
         0.5
     ],
     "processor_class": "MossVLProcessor",
-    "image_processor_type": "MossVLImageProcessorFast"
+    "image_processor_type": "MossVLImageProcessorFast",
+    "interpolation": "BICUBIC"
 }

processing_moss_vl.py

@@ -49,24 +49,28 @@ class MossVLImageProcessorFast(Qwen2VLImageProcessorFast):
     """
     # Multi-image batch total pixels limit (read from config)
     multi_image_max_pixels = None
-    
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not hasattr(self, 'interpolation') or self.interpolation is None:
+            self.interpolation = "BICUBIC"
 
     def _preprocess(
         self,
         images: list["torch.Tensor"],
         do_resize: bool,
         size: SizeDict,
-        interpolation: Optional["F.InterpolationMode"],
-        do_rescale: bool,
-        rescale_factor: float,
-        do_normalize: bool,
-        image_mean: Optional[Union[float, list[float]]],
-        image_std: Optional[Union[float, list[float]]],
-        patch_size: int,
-        temporal_patch_size: int,
-        merge_size: int,
-        disable_grouping: Optional[bool],
-        return_tensors: Optional[Union[str, TensorType]],
+        interpolation: Optional["F.InterpolationMode"] = None,
+        do_rescale: bool = True,
+        rescale_factor: float = 1 / 255,
+        do_normalize: bool = True,
+        image_mean: Optional[Union[float, list[float]]] = None,
+        image_std: Optional[Union[float, list[float]]] = None,
+        patch_size: int = 16,
+        temporal_patch_size: int = 1,
+        merge_size: int = 2,
+        disable_grouping: Optional[bool] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
         **kwargs,
     ):
         """Override _preprocess to use custom smart_resize with batch-level max_pixels.
@@ -164,12 +168,17 @@ class MossVLImageProcessorFast(Qwen2VLImageProcessorFast):
             )
             # Reorder dimensions to group grid and patch information for subsequent flattening.
             # (batch, grid_t, grid_h, grid_w, merge_h, merge_w, channel, temp_patch_size, patch_h, patch_w)
+            # NPU supports max 8D tensors; route the 10D permute+reshape through
+            # CPU there. CUDA handles 10D natively — keep it on-device.
+            patches_device = patches.device
+            if patches_device.type == "npu":
+                patches = patches.cpu()
             patches = patches.permute(0, 1, 4, 7, 5, 8, 3, 2, 6, 9)
             flatten_patches = patches.reshape(
                 batch_size,
                 grid_t * grid_h * grid_w,
                 channel * temporal_patch_size * patch_size * patch_size,
-            )
+            ).to(patches_device)
 
             processed_images_grouped[shape] = flatten_patches
             processed_grids[shape] = [[grid_t, grid_h, grid_w]] * batch_size
@@ -272,7 +281,7 @@ class MossVLImagesKwargs(ImagesKwargs):
     patch_size: Optional[int]
     temporal_patch_size: Optional[int]
     merge_size: Optional[int]
-
+    interpolation: Optional[str]
 
 
 class MossVLVideosKwargs(VideosKwargs, total=False):

video_processing_moss_vl.py

@@ -1147,12 +1147,17 @@ class MossVLVideoProcessor(BaseVideoProcessor):
                 merge_size,
                 patch_size,
             )
+            patches_device = patches.device
+            # NPU: max 8D tensors — route the 10D permute+reshape through CPU.
+            # CUDA handles 10D natively — keep it on-device.
+            if patches_device.type == "npu":
+                patches = patches.cpu()
             patches = patches.permute(0, 1, 4, 7, 5, 8, 3, 2, 6, 9)
             flatten_patches = patches.reshape(
                 batch_size,
                 grid_t * grid_h * grid_w,
                 channel * temporal_patch_size * patch_size * patch_size,
-            )
+            ).to(patches_device)
 
             processed_videos_grouped[shape] = flatten_patches
             processed_grids[shape] = [[grid_t, grid_h, grid_w]] * batch_size