support cos_sin_cache prefetch for qwen2

Author: Pr0Wh1teGivee

vllm_ascend/models/qwen2.py

@@ -1,10 +1,11 @@
 from collections.abc import Iterable
-from typing import Optional, Union
+from typing import Optional, Union, Any
 
 import torch
 import torch.nn.functional as F
 from torch import nn
 from transformers import Qwen2Config
+from vllm.attention import AttentionType
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
 from vllm.distributed import (get_pp_group, get_tensor_model_parallel_rank,
@@ -17,7 +18,7 @@
 from vllm.model_executor.layers.quantization import QuantizationConfig
 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
 from vllm.model_executor.models.interfaces import SupportsLoRA, SupportsPP
-from vllm.model_executor.models.qwen2 import Qwen2DecoderLayer, Qwen2Model
+from vllm.model_executor.models.qwen2 import Qwen2DecoderLayer, Qwen2Model, Qwen2Attention
 from vllm.model_executor.models.utils import (AutoWeightsLoader,
                                               PPMissingLayer, maybe_prefix)
 from vllm.model_executor.sampling_metadata import SamplingMetadata
@@ -47,6 +48,49 @@ def maybe_pad_and_reduce_scatter(
     return hidden_states
 
 
+class CustomQwen2Attention(Qwen2Attention):
+
+    def __init__(
+        self,
+        hidden_size: int,
+        num_heads: int,
+        num_kv_heads: int,
+        max_position: int = 4096 * 32,
+        rope_theta: float = 10000,
+        cache_config: Optional[CacheConfig] = None,
+        quant_config: Optional[QuantizationConfig] = None,
+        rope_scaling: Optional[tuple] = None,
+        prefix: str = "",
+        attn_type: str = AttentionType.DECODER,
+        dual_chunk_attention_config: Optional[dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(hidden_size=hidden_size,
+                         num_heads=num_heads,
+                         num_kv_heads=num_kv_heads,
+                         max_position=max_position,
+                         rope_theta=rope_theta,
+                         cache_config=cache_config,
+                         quant_config=quant_config,
+                         rope_scaling=rope_scaling,
+                         prefix=prefix,
+                         attn_type=attn_type,
+                         dual_chunk_attention_config=dual_chunk_attention_config)
+
+    def forward(
+        self,
+        positions: torch.Tensor,
+        hidden_states: torch.Tensor,
+        cos: torch.Tensor,
+        sin: torch.Tensor
+    ) -> torch.Tensor:
+        qkv, _ = self.qkv_proj(hidden_states)
+        q, k, v = qkv.split([self.q_size, self.kv_size, self.kv_size], dim=-1)
+        q, k = self.rotary_emb(positions, q, k, cos=cos, sin=sin, skip_index_select=True)
+        attn_output = self.attn(q, k, v)
+        output, _ = self.o_proj(attn_output)
+        return output
+
+
 class CustomQwen2DecoderLayer(Qwen2DecoderLayer):
 
     def __init__(
@@ -68,6 +112,8 @@ def __init__(
     def forward(
         self,
         positions: torch.Tensor,
+        cos: torch.Tensor,
+        sin: torch.Tensor,
         hidden_states: torch.Tensor,
         residual: Optional[torch.Tensor],
         flashcomm_v1_enabled: bool,
@@ -91,6 +137,8 @@ def forward(
         hidden_states = self.self_attn(
             positions=positions,
             hidden_states=hidden_states,
+            cos=cos,
+            sin=sin
         )
         if flashcomm_v1_enabled:
             hidden_states = maybe_pad_and_reduce_scatter(
@@ -132,7 +180,8 @@ def __init__(
                          prefix=prefix,
                          decoder_layer_type=decoder_layer_type)
         self.tp_size = get_tensor_model_parallel_world_size()
-
+        self.rotary_emb = self.layers[0].self_attn.rotary_emb
+        self.cos_sin_cache = self.rotary_emb.cos_sin_cache
     def forward(
         self,
         input_ids: torch.Tensor,
@@ -161,9 +210,19 @@ def forward(
             num_tokens = hidden_states.size(0)
             pad_size = (self.tp_size -
                         (num_tokens % self.tp_size)) % self.tp_size
+            
+        cos_sin = self.cos_sin_cache.index_select(0, positions)
+        head_dim = cos_sin.size()[-1]
+        cos, sin = cos_sin.reshape(-1, 2,
+                                   head_dim // 2).repeat(1, 1, 2).chunk(2, dim=-2)
+        cos = cos.view(1, -1, 1, head_dim).contiguous()
+        sin = sin.view(1, -1, 1, head_dim).contiguous()
+        
         for layer in self.layers[self.start_layer:self.end_layer]:
             hidden_states, residual = layer(
                 positions,
+                cos,
+                sin,
                 hidden_states,
                 residual,
                 flashcomm_v1_enabled,