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

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
 
@@ -3596,7 +3604,16 @@ class MossVLForConditionalGeneration(MossVLPreTrainedModel, GenerationMixin):
                     and buf_list[-1] == invalid_token_id
                 )
                 if is_silence_or_ellipsis or is_complete_text or is_invalid_complete:
-                    output_text_queue.put(decoded_text)
+                    # The end-of-buffer guard above only catches an INCOMPLETE
+                    # trailing char. Under sampling, a multi-byte char can also
+                    # break MID-string (the next token completes a different
+                    # char, orphaning the first char's tail bytes) — the
+                    # replacement char then stays in the text forever. Those
+                    # bytes are unrecoverable at this point: drop the broken
+                    # character instead of emitting mojibake.
+                    clean_text = decoded_text.replace("\ufffd", "")
+                    if clean_text:
+                        output_text_queue.put(clean_text)
                     token_buffer.clear()
 
             input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)

processing_moss_vl.py

@@ -164,12 +164,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 ops support at most 8-D tensors; route the 10-D permute+reshape
+            # through CPU there. CUDA handles 10-D 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

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