cache-dit 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

cache_dit/cache_factory/cache_blocks/__init__.py

@@ -1,28 +1,33 @@
 import torch
 
 from cache_dit.cache_factory import ForwardPattern
+from cache_dit.cache_factory.cache_types import CacheType
 from cache_dit.cache_factory.cache_contexts.cache_context import CachedContext
+from cache_dit.cache_factory.cache_contexts.prune_context import PrunedContext
 from cache_dit.cache_factory.cache_contexts.cache_manager import (
     CachedContextManager,
 )
+from cache_dit.cache_factory.cache_contexts.prune_manager import (
+    PrunedContextManager,
+)
 
 from cache_dit.cache_factory.cache_blocks.pattern_0_1_2 import (
     CachedBlocks_Pattern_0_1_2,
+    PrunedBlocks_Pattern_0_1_2,
 )
 from cache_dit.cache_factory.cache_blocks.pattern_3_4_5 import (
     CachedBlocks_Pattern_3_4_5,
+    PrunedBlocks_Pattern_3_4_5,
 )
-from cache_dit.cache_factory.cache_blocks.pattern_utils import (
-    patch_cached_stats,
-    remove_cached_stats,
-)
+from cache_dit.cache_factory.cache_blocks.pattern_utils import apply_stats
+from cache_dit.cache_factory.cache_blocks.pattern_utils import remove_stats
 
 from cache_dit.logger import init_logger
 
 logger = init_logger(__name__)
 
 
-class CachedBlocks:
+class UnifiedBlocks:
     def __new__(
         cls,
         # 0. Transformer blocks configuration
@@ -36,16 +41,13 @@ class CachedBlocks:
         # 'layers', 'single_stream_blocks', 'double_stream_blocks'
         cache_prefix: str = None,  # cache_prefix maybe un-need.
         # Usually, blocks_name, etc.
-        cache_context: CachedContext | str = None,
-        cache_manager: CachedContextManager = None,
+        cache_context: CachedContext | PrunedContext | str = None,
+        context_manager: CachedContextManager | PrunedContextManager = None,
+        cache_type: CacheType = CacheType.DBCache,
         **kwargs,
     ):
-        assert transformer is not None, "transformer can't be None."
-        assert forward_pattern is not None, "forward_pattern can't be None."
-        assert cache_context is not None, "cache_context can't be None."
-        assert cache_manager is not None, "cache_manager can't be None."
-        if forward_pattern in CachedBlocks_Pattern_0_1_2._supported_patterns:
-            return CachedBlocks_Pattern_0_1_2(
+        if cache_type == CacheType.DBCache:
+            return CachedBlocks(
                 # 0. Transformer blocks configuration
                 transformer_blocks,
                 transformer=transformer,
@@ -55,11 +57,12 @@ class CachedBlocks:
                 # 1. Cache context configuration
                 cache_prefix=cache_prefix,
                 cache_context=cache_context,
-                cache_manager=cache_manager,
+                context_manager=context_manager,
+                cache_type=cache_type,
                 **kwargs,
             )
-        elif forward_pattern in CachedBlocks_Pattern_3_4_5._supported_patterns:
-            return CachedBlocks_Pattern_3_4_5(
+        elif cache_type == CacheType.DBPrune:
+            return PrunedBlocks(
                 # 0. Transformer blocks configuration
                 transformer_blocks,
                 transformer=transformer,
@@ -69,8 +72,155 @@ class CachedBlocks:
                 # 1. Cache context configuration
                 cache_prefix=cache_prefix,
                 cache_context=cache_context,
-                cache_manager=cache_manager,
+                context_manager=context_manager,
+                cache_type=cache_type,
                 **kwargs,
             )
+        else:
+            raise ValueError(f"Cache type {cache_type} is not supported now!")
+
+
+class CachedBlocks:
+    def __new__(
+        cls,
+        # 0. Transformer blocks configuration
+        transformer_blocks: torch.nn.ModuleList,
+        transformer: torch.nn.Module = None,
+        forward_pattern: ForwardPattern = None,
+        check_forward_pattern: bool = True,
+        check_num_outputs: bool = True,
+        # 1. Cache context configuration
+        # 'transformer_blocks', 'blocks', 'single_transformer_blocks',
+        # 'layers', 'single_stream_blocks', 'double_stream_blocks'
+        cache_prefix: str = None,  # cache_prefix maybe un-need.
+        # Usually, blocks_name, etc.
+        cache_context: CachedContext | PrunedContext | str = None,
+        context_manager: CachedContextManager | PrunedContextManager = None,
+        cache_type: CacheType = CacheType.DBCache,
+        **kwargs,
+    ):
+        assert transformer is not None, "transformer can't be None."
+        assert forward_pattern is not None, "forward_pattern can't be None."
+        assert cache_context is not None, "cache_context can't be None."
+        assert context_manager is not None, "context_manager can't be None."
+        if forward_pattern in CachedBlocks_Pattern_0_1_2._supported_patterns:
+            if cache_type == CacheType.DBCache:
+                assert isinstance(
+                    context_manager, CachedContextManager
+                ), "context_manager must be CachedContextManager for DBCache."
+                return CachedBlocks_Pattern_0_1_2(
+                    # 0. Transformer blocks configuration
+                    transformer_blocks,
+                    transformer=transformer,
+                    forward_pattern=forward_pattern,
+                    check_forward_pattern=check_forward_pattern,
+                    check_num_outputs=check_num_outputs,
+                    # 1. Cache context configuration
+                    cache_prefix=cache_prefix,
+                    cache_context=cache_context,
+                    context_manager=context_manager,
+                    cache_type=cache_type,
+                    **kwargs,
+                )
+            else:
+                raise ValueError(
+                    f"Cache type {cache_type} is not supported now!"
+                )
+        elif forward_pattern in CachedBlocks_Pattern_3_4_5._supported_patterns:
+            if cache_type == CacheType.DBCache:
+                assert isinstance(
+                    context_manager, CachedContextManager
+                ), "context_manager must be CachedContextManager for DBCache."
+                return CachedBlocks_Pattern_3_4_5(
+                    # 0. Transformer blocks configuration
+                    transformer_blocks,
+                    transformer=transformer,
+                    forward_pattern=forward_pattern,
+                    check_forward_pattern=check_forward_pattern,
+                    check_num_outputs=check_num_outputs,
+                    # 1. Cache context configuration
+                    cache_prefix=cache_prefix,
+                    cache_context=cache_context,
+                    context_manager=context_manager,
+                    cache_type=cache_type,
+                    **kwargs,
+                )
+            else:
+                raise ValueError(
+                    f"Cache type {cache_type} is not supported now!"
+                )
+        else:
+            raise ValueError(f"Pattern {forward_pattern} is not supported now!")
+
+
+class PrunedBlocks:
+    def __new__(
+        cls,
+        # 0. Transformer blocks configuration
+        transformer_blocks: torch.nn.ModuleList,
+        transformer: torch.nn.Module = None,
+        forward_pattern: ForwardPattern = None,
+        check_forward_pattern: bool = True,
+        check_num_outputs: bool = True,
+        # 1. Cache context configuration
+        # 'transformer_blocks', 'blocks', 'single_transformer_blocks',
+        # 'layers', 'single_stream_blocks', 'double_stream_blocks'
+        cache_prefix: str = None,  # cache_prefix maybe un-need.
+        # Usually, blocks_name, etc.
+        cache_context: CachedContext | PrunedContext | str = None,
+        context_manager: CachedContextManager | PrunedContextManager = None,
+        cache_type: CacheType = CacheType.DBCache,
+        **kwargs,
+    ):
+        assert transformer is not None, "transformer can't be None."
+        assert forward_pattern is not None, "forward_pattern can't be None."
+        assert cache_context is not None, "cache_context can't be None."
+        assert context_manager is not None, "context_manager can't be None."
+        if forward_pattern in PrunedBlocks_Pattern_0_1_2._supported_patterns:
+            if cache_type == CacheType.DBPrune:
+                assert isinstance(
+                    context_manager, PrunedContextManager
+                ), "context_manager must be PrunedContextManager for DBPrune."
+                return PrunedBlocks_Pattern_0_1_2(
+                    # 0. Transformer blocks configuration
+                    transformer_blocks,
+                    transformer=transformer,
+                    forward_pattern=forward_pattern,
+                    check_forward_pattern=check_forward_pattern,
+                    check_num_outputs=check_num_outputs,
+                    # 1. Cache context configuration
+                    cache_prefix=cache_prefix,
+                    cache_context=cache_context,
+                    context_manager=context_manager,
+                    cache_type=cache_type,
+                    **kwargs,
+                )
+            else:
+                raise ValueError(
+                    f"Cache type {cache_type} is not supported now!"
+                )
+        elif forward_pattern in PrunedBlocks_Pattern_3_4_5._supported_patterns:
+            if cache_type == CacheType.DBPrune:
+                assert isinstance(
+                    context_manager, PrunedContextManager
+                ), "context_manager must be PrunedContextManager for DBPrune."
+                return PrunedBlocks_Pattern_3_4_5(
+                    # 0. Transformer blocks configuration
+                    transformer_blocks,
+                    transformer=transformer,
+                    forward_pattern=forward_pattern,
+                    check_forward_pattern=check_forward_pattern,
+                    check_num_outputs=check_num_outputs,
+                    # 1. Cache context configuration
+                    cache_prefix=cache_prefix,
+                    cache_context=cache_context,
+                    context_manager=context_manager,
+                    cache_type=cache_type,
+                    **kwargs,
+                )
+            else:
+                raise ValueError(
+                    f"Cache type {cache_type} is not supported now!"
+                )
         else:
             raise ValueError(f"Pattern {forward_pattern} is not supported now!")

cache_dit/cache_factory/cache_blocks/pattern_0_1_2.py

@@ -1,6 +1,7 @@
 from cache_dit.cache_factory import ForwardPattern
 from cache_dit.cache_factory.cache_blocks.pattern_base import (
     CachedBlocks_Pattern_Base,
+    PrunedBlocks_Pattern_Base,
 )
 from cache_dit.logger import init_logger
 
@@ -14,3 +15,12 @@ class CachedBlocks_Pattern_0_1_2(CachedBlocks_Pattern_Base):
         ForwardPattern.Pattern_2,
     ]
     ...
+
+
+class PrunedBlocks_Pattern_0_1_2(PrunedBlocks_Pattern_Base):
+    _supported_patterns = [
+        ForwardPattern.Pattern_0,
+        ForwardPattern.Pattern_1,
+        ForwardPattern.Pattern_2,
+    ]
+    ...

cache_dit/cache_factory/cache_blocks/pattern_3_4_5.py

@@ -2,11 +2,17 @@ import torch
 
 from cache_dit.cache_factory import ForwardPattern
 from cache_dit.cache_factory.cache_contexts.cache_manager import (
-    CacheNotExistError,
+    ContextNotExistError,
 )
 from cache_dit.cache_factory.cache_blocks.pattern_base import (
     CachedBlocks_Pattern_Base,
 )
+from cache_dit.cache_factory.cache_contexts.prune_context import PrunedContext
+from cache_dit.cache_factory.cache_contexts.prune_manager import (
+    PrunedContextManager,
+)
+from cache_dit.cache_factory.cache_types import CacheType
+
 from cache_dit.logger import init_logger
 
 logger = init_logger(__name__)
@@ -91,10 +97,10 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
     ):
         # Use it's own cache context.
         try:
-            self.cache_manager.set_context(self.cache_context)
+            self.context_manager.set_context(self.cache_context)
             self._check_cache_params()
-        except CacheNotExistError as e:
-            logger.warning(f"Cache context not exist: {e}, skip cache.")
+        except ContextNotExistError as e:
+            logger.warning(f"context not exist: {e}, skip cache.")
             hidden_states, new_encoder_hidden_states = self.call_blocks(
                 hidden_states,
                 *args,
@@ -118,38 +124,38 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
         )
         del original_hidden_states
 
-        self.cache_manager.mark_step_begin()
+        self.context_manager.mark_step_begin()
         # Residual L1 diff or Hidden States L1 diff
-        can_use_cache = self.cache_manager.can_cache(
+        can_use_cache = self.context_manager.can_cache(
             (
                 Fn_hidden_states_residual
-                if not self.cache_manager.is_l1_diff_enabled()
+                if not self.context_manager.is_l1_diff_enabled()
                 else hidden_states
             ),
             parallelized=self._is_parallelized(),
             prefix=(
                 f"{self.cache_prefix}_Fn_residual"
-                if not self.cache_manager.is_l1_diff_enabled()
+                if not self.context_manager.is_l1_diff_enabled()
                 else f"{self.cache_prefix}_Fn_hidden_states"
             ),
         )
 
         torch._dynamo.graph_break()
         if can_use_cache:
-            self.cache_manager.add_cached_step()
+            self.context_manager.add_cached_step()
             del Fn_hidden_states_residual
             hidden_states, new_encoder_hidden_states = (
-                self.cache_manager.apply_cache(
+                self.context_manager.apply_cache(
                     hidden_states,
                     new_encoder_hidden_states,  # encoder_hidden_states not use cache
                     prefix=(
                         f"{self.cache_prefix}_Bn_residual"
-                        if self.cache_manager.is_cache_residual()
+                        if self.context_manager.is_cache_residual()
                         else f"{self.cache_prefix}_Bn_hidden_states"
                     ),
                     encoder_prefix=(
                         f"{self.cache_prefix}_Bn_residual"
-                        if self.cache_manager.is_encoder_cache_residual()
+                        if self.context_manager.is_encoder_cache_residual()
                         else f"{self.cache_prefix}_Bn_hidden_states"
                     ),
                 )
@@ -157,20 +163,20 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
             torch._dynamo.graph_break()
             # Call last `n` blocks to further process the hidden states
             # for higher precision.
-            if self.cache_manager.Bn_compute_blocks() > 0:
+            if self.context_manager.Bn_compute_blocks() > 0:
                 hidden_states, new_encoder_hidden_states = self.call_Bn_blocks(
                     hidden_states,
                     *args,
                     **kwargs,
                 )
         else:
-            self.cache_manager.set_Fn_buffer(
+            self.context_manager.set_Fn_buffer(
                 Fn_hidden_states_residual,
                 prefix=f"{self.cache_prefix}_Fn_residual",
             )
-            if self.cache_manager.is_l1_diff_enabled():
+            if self.context_manager.is_l1_diff_enabled():
                 # for hidden states L1 diff
-                self.cache_manager.set_Fn_buffer(
+                self.context_manager.set_Fn_buffer(
                     hidden_states,
                     f"{self.cache_prefix}_Fn_hidden_states",
                 )
@@ -188,13 +194,13 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
             )
 
             torch._dynamo.graph_break()
-            if self.cache_manager.is_cache_residual():
-                self.cache_manager.set_Bn_buffer(
+            if self.context_manager.is_cache_residual():
+                self.context_manager.set_Bn_buffer(
                     hidden_states_residual,
                     prefix=f"{self.cache_prefix}_Bn_residual",
                 )
             else:
-                self.cache_manager.set_Bn_buffer(
+                self.context_manager.set_Bn_buffer(
                     hidden_states,
                     prefix=f"{self.cache_prefix}_Bn_hidden_states",
                 )
@@ -203,22 +209,22 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
                 new_encoder_hidden_states_residual = (
                     new_encoder_hidden_states - old_encoder_hidden_states
                 )
-            if self.cache_manager.is_encoder_cache_residual():
+            if self.context_manager.is_encoder_cache_residual():
                 if new_encoder_hidden_states is not None:
-                    self.cache_manager.set_Bn_encoder_buffer(
+                    self.context_manager.set_Bn_encoder_buffer(
                         new_encoder_hidden_states_residual,
                         prefix=f"{self.cache_prefix}_Bn_residual",
                     )
             else:
                 if new_encoder_hidden_states is not None:
-                    self.cache_manager.set_Bn_encoder_buffer(
+                    self.context_manager.set_Bn_encoder_buffer(
                         new_encoder_hidden_states_residual,
                         prefix=f"{self.cache_prefix}_Bn_hidden_states",
                     )
             torch._dynamo.graph_break()
             # Call last `n` blocks to further process the hidden states
             # for higher precision.
-            if self.cache_manager.Bn_compute_blocks() > 0:
+            if self.context_manager.Bn_compute_blocks() > 0:
                 hidden_states, new_encoder_hidden_states = self.call_Bn_blocks(
                     hidden_states,
                     *args,
@@ -289,7 +295,7 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
         **kwargs,
     ):
         new_encoder_hidden_states = None
-        if self.cache_manager.Bn_compute_blocks() == 0:
+        if self.context_manager.Bn_compute_blocks() == 0:
             return hidden_states, new_encoder_hidden_states
 
         for block in self._Bn_blocks():
@@ -304,3 +310,229 @@ class CachedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_Base):
             )
 
         return hidden_states, new_encoder_hidden_states
+
+
+class PrunedBlocks_Pattern_3_4_5(CachedBlocks_Pattern_3_4_5):
+    _supported_patterns = [
+        ForwardPattern.Pattern_3,
+        ForwardPattern.Pattern_4,
+        ForwardPattern.Pattern_5,
+    ]
+    pruned_blocks_step: int = 0  # number of pruned blocks in current step
+
+    def __init__(
+        self,
+        # 0. Transformer blocks configuration
+        transformer_blocks: torch.nn.ModuleList,
+        transformer: torch.nn.Module = None,
+        forward_pattern: ForwardPattern = ForwardPattern.Pattern_0,
+        check_forward_pattern: bool = True,
+        check_num_outputs: bool = True,
+        # 1. Prune context configuration
+        cache_prefix: str = None,  # maybe un-need.
+        cache_context: PrunedContext | str = None,
+        context_manager: PrunedContextManager = None,
+        cache_type: CacheType = CacheType.DBPrune,
+        **kwargs,
+    ):
+        super().__init__(
+            # 0. Transformer blocks configuration
+            transformer_blocks,
+            transformer=transformer,
+            forward_pattern=forward_pattern,
+            check_forward_pattern=check_forward_pattern,
+            check_num_outputs=check_num_outputs,
+            # 1. Cache context configuration
+            cache_prefix=cache_prefix,
+            cache_context=cache_context,
+            context_manager=context_manager,
+            cache_type=cache_type,
+            **kwargs,
+        )
+        assert isinstance(
+            self.context_manager, PrunedContextManager
+        ), "context_manager must be PrunedContextManager for PrunedBlocks."
+        self.context_manager: PrunedContextManager = (
+            self.context_manager
+        )  # For type hint
+
+    @torch.compiler.disable
+    def _check_cache_type(self):
+        assert (
+            self.cache_type == CacheType.DBPrune
+        ), f"Cache type {self.cache_type} is not supported for PrunedBlocks."
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        *args,
+        **kwargs,
+    ):
+        self.pruned_blocks_step: int = 0  # reset for each step
+
+        # Use it's own cache context.
+        try:
+            self.context_manager.set_context(self.cache_context)
+            self._check_cache_params()
+        except ContextNotExistError as e:
+            logger.warning(f"context not exist: {e}, skip prune.")
+            hidden_states, new_encoder_hidden_states = self.call_blocks(
+                hidden_states,
+                *args,
+                **kwargs,
+            )
+            return self._process_forward_outputs(
+                hidden_states, new_encoder_hidden_states
+            )
+
+        self.context_manager.mark_step_begin()
+
+        # Call all blocks with prune strategy to process the hidden states.
+        new_encoder_hidden_states = None
+        for i, block in enumerate(self.transformer_blocks):
+            hidden_states, new_encoder_hidden_states = self.compute_or_prune(
+                i,
+                block,
+                hidden_states,
+                new_encoder_hidden_states,
+                *args,
+                **kwargs,
+            )
+
+        self.context_manager.add_pruned_block(self.pruned_blocks_step)
+        self.context_manager.add_actual_block(self.num_blocks)
+
+        return self._process_forward_outputs(
+            hidden_states,
+            new_encoder_hidden_states,
+        )
+
+    @property
+    @torch.compiler.disable
+    def num_blocks(self):
+        return len(self.transformer_blocks)
+
+    @torch.compiler.disable
+    def _skip_prune(self, block_id: int) -> bool:
+        # Wrap for non compiled mode.
+        return block_id in self.context_manager.get_non_prune_blocks_ids(
+            self.num_blocks
+        )
+
+    @torch.compiler.disable
+    def _maybe_prune(
+        self,
+        block_id: int,  # Block index in the transformer blocks
+        hidden_states: torch.Tensor,  # hidden_states or residual
+        prefix: str = "Bn_original",  # prev step name for single blocks
+    ):
+        # Wrap for non compiled mode.
+        can_use_prune = False
+        if not self._skip_prune(block_id):
+            can_use_prune = self.context_manager.can_prune(
+                hidden_states,  # curr step
+                parallelized=self._is_parallelized(),
+                prefix=prefix,  # prev step
+            )
+        self.pruned_blocks_step += int(can_use_prune)
+        return can_use_prune
+
+    def compute_or_prune(
+        self,
+        block_id: int,  # Block index in the transformer blocks
+        # Below are the inputs to the block
+        block,  # The transformer block to be executed
+        hidden_states: torch.Tensor,
+        new_encoder_hidden_states: torch.Tensor | None,
+        *args,
+        **kwargs,
+    ):
+        original_hidden_states = hidden_states
+        original_encoder_hidden_states = new_encoder_hidden_states
+
+        can_use_prune = self._maybe_prune(
+            block_id,
+            hidden_states,
+            prefix=f"{self.cache_prefix}_{block_id}_Fn_original",
+        )
+
+        # Prune steps: Prune current block and reuse the cached
+        # residuals for hidden states approximate.
+        torch._dynamo.graph_break()
+        if can_use_prune:
+            self.context_manager.add_pruned_step()
+            hidden_states, new_encoder_hidden_states = (
+                self.context_manager.apply_prune(
+                    hidden_states,
+                    new_encoder_hidden_states,
+                    prefix=(
+                        f"{self.cache_prefix}_{block_id}_Bn_residual"
+                        if self.context_manager.is_cache_residual()
+                        else f"{self.cache_prefix}_{block_id}_Bn_hidden_states"
+                    ),
+                    encoder_prefix=(
+                        f"{self.cache_prefix}_{block_id}_Bn_encoder_residual"
+                        if self.context_manager.is_encoder_cache_residual()
+                        else f"{self.cache_prefix}_{block_id}_Bn_encoder_hidden_states"
+                    ),
+                )
+            )
+            torch._dynamo.graph_break()
+        else:
+            # Normal steps: Compute the block and cache the residuals.
+            hidden_states = block(
+                hidden_states,
+                *args,
+                **kwargs,
+            )
+            hidden_states, new_encoder_hidden_states = (
+                self._process_block_outputs(
+                    hidden_states, new_encoder_hidden_states
+                )
+            )
+            if not self._skip_prune(block_id):
+                hidden_states = hidden_states.contiguous()
+                hidden_states_residual = hidden_states - original_hidden_states
+
+                if (
+                    new_encoder_hidden_states is not None
+                    and original_encoder_hidden_states is not None
+                ):
+                    new_encoder_hidden_states = (
+                        new_encoder_hidden_states.contiguous()
+                    )
+                    new_encoder_hidden_states_residual = (
+                        new_encoder_hidden_states
+                        - original_encoder_hidden_states
+                    )
+                else:
+                    new_encoder_hidden_states_residual = None
+
+                self.context_manager.set_Fn_buffer(
+                    original_hidden_states,
+                    prefix=f"{self.cache_prefix}_{block_id}_Fn_original",
+                )
+                if self.context_manager.is_cache_residual():
+                    self.context_manager.set_Bn_buffer(
+                        hidden_states_residual,
+                        prefix=f"{self.cache_prefix}_{block_id}_Bn_residual",
+                    )
+                else:
+                    self.context_manager.set_Bn_buffer(
+                        hidden_states,
+                        prefix=f"{self.cache_prefix}_{block_id}_Bn_hidden_states",
+                    )
+                if new_encoder_hidden_states_residual is not None:
+                    if self.context_manager.is_encoder_cache_residual():
+                        self.context_manager.set_Bn_encoder_buffer(
+                            new_encoder_hidden_states_residual,
+                            prefix=f"{self.cache_prefix}_{block_id}_Bn_encoder_residual",
+                        )
+                    else:
+                        self.context_manager.set_Bn_encoder_buffer(
+                            new_encoder_hidden_states_residual,
+                            prefix=f"{self.cache_prefix}_{block_id}_Bn_encoder_hidden_states",
+                        )
+            torch._dynamo.graph_break()
+
+        return hidden_states, new_encoder_hidden_states