Method forward

lingbot_map/layers/block.py:229–302

(
        self,
        x: Tensor,
        pos=None,
        num_patches=None,
        num_special=None,
        num_frames=None,
        enable_3d_rope=False,
        kv_cache=None,
        global_idx=0,
        num_frame_per_block=1,
        num_frame_for_scale=-1,
        num_register_tokens=4,
    )

        return self.attn.prepare_qkv(self.norm1(x), pos=pos, enable_3d_rope=enable_3d_rope)

    def forward(
        self,
        x: Tensor,
        pos=None,
        num_patches=None,
        num_special=None,
        num_frames=None,
        enable_3d_rope=False,
        kv_cache=None,
        global_idx=0,
        num_frame_per_block=1,
        num_frame_for_scale=-1,
        num_register_tokens=4,
    ) -> Tensor:
        # Phase 2 (streaming): single-frame FlashInfer paged attention.
        # Handle inline so attn_pre (norm1+prepare_qkv) can be compiled as one CUDA graph.
        is_streaming = (kv_cache is not None and (num_frames is None or num_frames <= 1))
        if is_streaming:
            manager = kv_cache
            # Compiled: norm1 + qkv linear + reshape + q_norm + k_norm + RoPE + format
            q_nhd, k_nhd, v_nhd = self.attn_pre(x, pos=pos, enable_3d_rope=enable_3d_rope)

            # Non-keyframe path: attend to cache+current but don't persist the
            # current frame.  FlashInfer paged attention can only read from the
            # paged cache, so we temporarily append (with eviction deferred so
            # it stays clean), attend, and then roll back the append.  Mirrors
            # the ``skip_append`` behavior of the SDPA dict path.
            skip_append = getattr(manager, '_skip_append', False)
            if skip_append:
                prev_defer = manager._defer_eviction
                manager._defer_eviction = True
                manager.append_frame(global_idx, k_nhd, v_nhd)
                attn_x = manager.compute_attention(global_idx, q_nhd)
                manager.rollback_last_frame(global_idx)
                manager._defer_eviction = prev_defer
            else:
                # Eager: write frame K/V to paged cache
                manager.append_frame(global_idx, k_nhd, v_nhd)
                # CPU-only: update eviction state (deque ops, no GPU kernel)
                manager.evict_frames(
                    block_idx=global_idx,
                    scale_frames=self.attn.kv_cache_scale_frames,
                    sliding_window=self.attn.kv_cache_sliding_window,
                    cross_frame_special=self.attn.kv_cache_cross_frame_special,
                    include_scale_frames=self.attn.kv_cache_include_scale_frames,
                    camera_only=self.attn.kv_cache_camera_only,
                    num_register_tokens=num_register_tokens,
                )
                # Eager: FlashInfer BatchPrefillWithPagedKVCacheWrapper
                attn_x = manager.compute_attention(global_idx, q_nhd)

            # [tpf, H, D] -> [B, tpf, C]  (B=1 in streaming, contiguous from FlashInfer output)
            attn_x = attn_x.reshape(x.shape[0], q_nhd.shape[0],
                                    self.attn.num_heads * self.attn.head_dim)
            # Compiled: output projection
            attn_x = self.attn.proj(attn_x)
            x = x + self.ls1(attn_x)
        else: