From bbe5ef3783218a66dd09163a3c8f6c6bf1acef2a Mon Sep 17 00:00:00 2001 From: Yishuo Wang Date: Wed, 12 Jun 2024 16:37:47 +0800 Subject: [PATCH] refactor chatglm2/3 --- .../ipex_llm/transformers/models/chatglm2.py | 633 ++++-------------- .../src/ipex_llm/transformers/models/utils.py | 2 +- 2 files changed, 132 insertions(+), 503 deletions(-) diff --git a/python/llm/src/ipex_llm/transformers/models/chatglm2.py b/python/llm/src/ipex_llm/transformers/models/chatglm2.py index 983a6533e89..2fa37d6361b 100644 --- a/python/llm/src/ipex_llm/transformers/models/chatglm2.py +++ b/python/llm/src/ipex_llm/transformers/models/chatglm2.py @@ -19,136 +19,26 @@ import math import torch -from typing import Optional, Tuple, List -import torch.nn.functional as F +from typing import Optional, Tuple from transformers.modeling_outputs import BaseModelOutputWithPast -from ipex_llm.transformers.models.utils import init_kv_cache, extend_kv_cache, append_kv_cache -from ipex_llm.transformers.models.utils import init_fp8_kv_cache, append_fp8_kv_cache, \ - restore_fp8_kv_cache, use_quantize_kv_cache, use_flash_attention -from ipex_llm.transformers.models.utils import use_sdp +from ipex_llm.utils.common.log4Error import invalidInputError +from ipex_llm.transformers.models.utils import restore_fp8_kv_cache, update_past_key_value +from ipex_llm.transformers.models.utils import use_quantize_kv_cache, use_sdp, use_sdp_causal +from ipex_llm.transformers.models.utils import should_use_fuse_rope, apply_rotary_pos_emb -import os - -KV_CACHE_ALLOC_BLOCK_LENGTH = int(os.environ.get("KV_CACHE_ALLOC_BLOCK_LENGTH", 256)) -KV_CACHE_ALLOC_MIN_LENGTH = 512 - - -def split_tensor_along_last_dim( - tensor: torch.Tensor, - num_partitions: int, - contiguous_split_chunks: bool = False, -) -> List[torch.Tensor]: - """Split a tensor along its last dimension. - Arguments: - tensor: input tensor. - num_partitions: number of partitions to split the tensor - contiguous_split_chunks: If True, make each chunk contiguous - in memory. - Returns: - A list of Tensors +def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor: """ - # Get the size and dimension. - last_dim = tensor.dim() - 1 - last_dim_size = tensor.size()[last_dim] // num_partitions - # Split. - tensor_list = torch.split(tensor, last_dim_size, dim=last_dim) - # Note: torch.split does not create contiguous tensors by default. - if contiguous_split_chunks: - return tuple(chunk.contiguous() for chunk in tensor_list) - - return tensor_list - - -def glm_sdpa(query, key, value, attention_mask=None, is_causal=False): - if use_flash_attention(query, key, attention_mask) or query.device.type == 'cpu': - context_layer = F.scaled_dot_product_attention(query.to(key.dtype), - key, - value, - attention_mask, - is_causal=is_causal).to(key.dtype) - else: - # attention_mask is not None only when past_key_value is not None and q_len > 1 - if attention_mask is not None: - attn_bias = torch.zeros(attention_mask.shape, dtype=query.dtype, - device=query.device) - attention_mask = ~attention_mask - if attention_mask.dtype == torch.bool: - attn_bias.masked_fill_(attention_mask.logical_not(), float("-inf")) - else: - attn_bias += attention_mask - elif is_causal: - L, S = query.size(-2), key.size(-2) - attn_bias = torch.zeros(L, S, dtype=query.dtype, device=query.device) - temp_mask = torch.ones(L, S, dtype=torch.bool, device=query.device).tril(diagonal=0) - attn_bias.masked_fill_(temp_mask.logical_not(), float("-inf")) - attn_bias.to(key.dtype) - else: - attn_bias = None - if use_sdp(query.shape[2], key.shape[2], - query.shape[-1], query): - import xe_addons - attn_output = xe_addons.sdp(query, key, value, attn_bias) - context_layer = attn_output.view(query.shape) - else: - head_dim = query.size(-1) - attn = torch.matmul(query.to(key.dtype), - key.transpose(2, 3)) / math.sqrt(head_dim) - if attn_bias is not None: - attn += attn_bias - attn = F.softmax(attn, dim=-1, - dtype=torch.float32).to(value.dtype) - context_layer = torch.matmul(attn, value) - return context_layer - - -@torch.jit.script -def apply_rotary_pos_emb_chatglm(x: torch.Tensor, rope_cache: torch.Tensor) -> torch.Tensor: - # x: [sq, b, np, hn] - sq, b, np, hn = x.size(0), x.size(1), x.size(2), x.size(3) - rot_dim = rope_cache.shape[-2] * 2 - x, x_pass = x[..., :rot_dim], x[..., rot_dim:] - # truncate to support variable sizes - rope_cache = rope_cache[:sq] - xshaped = x.reshape(sq, -1, np, rot_dim // 2, 2) - rope_cache = rope_cache.view(sq, -1, 1, xshaped.size(3), 2) - x_out2 = torch.stack( - [ - xshaped[..., 0] * rope_cache[..., 0] - xshaped[..., 1] * rope_cache[..., 1], - xshaped[..., 1] * rope_cache[..., 0] + xshaped[..., 0] * rope_cache[..., 1], - ], - -1, - ) - x_out2 = x_out2.flatten(3) - return torch.cat((x_out2, x_pass), dim=-1) - - -def repeat_kv(key: torch.Tensor, value: torch.Tensor, n_head: int) -> (torch.Tensor, torch.Tensor): - # key, value's shape: [bs, n_kv_head, seq_len, head_dim] -> [bs, n_head, seq_len, head_dim] - batch_size, n_kv_head, seq_len, head_dim = key.shape - - key = key.unsqueeze(2) - key = key.expand(-1, -1, n_head // n_kv_head, -1, -1) - key = key.contiguous().view(batch_size, n_head, seq_len, head_dim) - - value = value.unsqueeze(2) - value = value.expand(-1, -1, n_head // n_kv_head, -1, -1) - value = value.contiguous().view(batch_size, n_head, seq_len, head_dim) - - return key, value - - -def should_split_qkv_tensor(query_layer, bsz, n_head, seq_len): - if os.environ.get("IPEX_LLM_SPLIT_QKV", None) is not None: - return os.environ.get("IPEX_LLM_SPLIT_QKV", None) == "1" - elif query_layer.dtype == torch.float16 and query_layer.shape[2] >= 5000: - # split tensor for memory block limitation - # support fp16 and set input length threshold at 5000 for now - return True - elif query_layer.element_size()*bsz*n_head*seq_len*seq_len >= 4*1024**3: - # attn_weight size larger than memory block limitation 4GB - return True - return False + This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states + go from (batch, num_key_value_heads, seqlen, head_dim) to + (batch, num_attention_heads, seqlen, head_dim) + """ + batch, num_key_value_heads, slen, head_dim = hidden_states.shape + if n_rep == 1: + return hidden_states + hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, + n_rep, slen, head_dim) + return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim) def chatglm_rms_norm_forward(self, hidden_states): @@ -166,16 +56,16 @@ def chatglm_rms_norm_forward(self, hidden_states): def chatglm2_model_forward( - self, - input_ids, - position_ids: Optional[torch.Tensor]=None, - attention_mask: Optional[torch.BoolTensor]=None, - full_attention_mask: Optional[torch.BoolTensor]=None, - past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]]=None, - inputs_embeds: Optional[torch.Tensor]=None, - use_cache: Optional[bool]=None, - output_hidden_states: Optional[bool]=None, - return_dict: Optional[bool]=None, + self, + input_ids, + position_ids: Optional[torch.Tensor]=None, + attention_mask: Optional[torch.BoolTensor]=None, + full_attention_mask: Optional[torch.BoolTensor]=None, + past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]]=None, + inputs_embeds: Optional[torch.Tensor]=None, + use_cache: Optional[bool]=None, + output_hidden_states: Optional[bool]=None, + return_dict: Optional[bool]=None, ): output_hidden_states = ( output_hidden_states if output_hidden_states is not None @@ -196,33 +86,43 @@ def chatglm2_model_forward( past_key_values, padding_mask=attention_mask) - use_fuse_rope = input_ids.device.type == "xpu" - use_fuse_rope = use_fuse_rope and not self.training - - # Rotary positional embeddings - rotary_pos_emb = self.rotary_pos_emb(self.seq_length) - if position_ids is not None: - rotary_pos_emb = rotary_pos_emb[position_ids] - else: - rotary_pos_emb = rotary_pos_emb[None, :seq_length] - if use_fuse_rope: - # Repeat cos sin here, call only once for each token. - # Chatglm2's rotary embedding is similar to gptj's, is rotate_every_two. - # If put this to attension forward, it will generate too many times. - cos, sin = rotary_pos_emb.split(rotary_pos_emb.shape[-1] // 2, dim=-1) - cos = cos.squeeze(-1) - sin = sin.squeeze(-1) - cos = torch.repeat_interleave(cos[:, :, None, :], 2, 3) - sin = torch.repeat_interleave(sin[:, :, None, :], 2, 3) - rotary_pos_emb = (cos, sin) + # ipex-llm changes begin + # 1. replace `rotary_pos_emb` with `inv_freq` and `position_ids` + # 2. generate `causal_mask` and replace `full_attention_mask` with it + if position_ids is None: + if past_key_values is None: + position_ids = torch.arange(seq_length, dtype=torch.int64, device=inputs_embeds.device) + else: + kv_length = past_key_values[0][0].size(0) + position_ids = torch.arange(kv_length, kv_length + seq_length, + dtype=torch.int64, device=inputs_embeds.device) + position_ids = position_ids.repeat(batch_size, 1) + + # `full_attention_mask` is not None only when + # `past_key_values` is not None and `seq_length` > 1 + if full_attention_mask is not None: + causal_mask = torch.zeros([batch_size, 1, seq_length, full_attention_mask.size(-1)], + dtype=inputs_embeds.dtype, device=inputs_embeds.device) + mask_value = torch.finfo(inputs_embeds.dtype).min + causal_mask.masked_fill_(full_attention_mask, mask_value) + elif self.training or (inputs_embeds.device.type != "xpu" and past_key_values is None): + full_attention_mask = self.get_masks(input_ids, + past_key_values, + padding_mask=attention_mask) + causal_mask = torch.zeros([batch_size, 1, seq_length, full_attention_mask.size(-1)], + dtype=inputs_embeds.dtype, device=inputs_embeds.device) + mask_value = torch.finfo(inputs_embeds.dtype).min + causal_mask.masked_fill_(full_attention_mask, mask_value) else: - rotary_pos_emb = rotary_pos_emb.transpose(0, 1).contiguous() + causal_mask = None # Run encoder. hidden_states, presents, all_hidden_states, all_self_attentions = self.encoder( - inputs_embeds, full_attention_mask, rotary_pos_emb=rotary_pos_emb, + inputs_embeds, causal_mask, + rotary_pos_emb=(self.rotary_pos_emb.inv_freq, position_ids), kv_caches=past_key_values, use_cache=use_cache, output_hidden_states=output_hidden_states ) + # ipex-llm changes end if not return_dict: return tuple(v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] @@ -239,364 +139,93 @@ def chatglm2_model_forward( def chatglm2_attention_forward( self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True ): - if use_quantize_kv_cache(self.query_key_value, hidden_states.transpose(0, 1)): - forward_function = chatglm2_quantized_attention_forward_8eb45c - else: - forward_function = chatglm2_attention_forward_8eb45c - return forward_function( - self=self, - hidden_states=hidden_states, - attention_mask=attention_mask, - rotary_pos_emb=rotary_pos_emb, - kv_cache=kv_cache, - use_cache=use_cache - ) + # hidden_states: [seq_len, bsz, head_dim] + q_len, bsz, _ = hidden_states.size() - -def chatglm2_quantized_attention_forward_8eb45c( - self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True -): - # hidden_states: [seq_len, bs, head_dim] - mixed_x_layer = self.query_key_value(hidden_states) + # kv_cache: [seq_len, bsz, n_kv_head, head_dim] -> + # past_key_value: [bsz, n_kv_head, seq_len, head_dim] + past_key_value = None if kv_cache is None else (kv_cache[0].permute(1, 2, 0, 3), + kv_cache[1].permute(1, 2, 0, 3)) n_head = self.num_attention_heads_per_partition n_kv_head = self.num_multi_query_groups_per_partition if self.multi_query_attention else n_head head_dim = self.hidden_size_per_attention_head - query_layer, key_layer, value_layer = mixed_x_layer.split( - [n_head * head_dim, n_kv_head * head_dim, n_kv_head * head_dim], - dim=-1, - ) - query_layer = query_layer.view(query_layer.shape[:-1] + (n_head, head_dim)) - key_layer = key_layer.view(key_layer.shape[:-1] + (n_kv_head, head_dim)) - value_layer = value_layer.view(value_layer.shape[:-1] + (n_kv_head, head_dim)) - # query, key, value's shape: [seq_len, bs, n_head/n_kv_head, head_dim] - - # apply relative positional encoding (rotary embedding) - if rotary_pos_emb is not None: - if len(rotary_pos_emb) == 2 and isinstance(rotary_pos_emb, tuple): - # use_fuse_rope, see chatglm2_model_forward - cos, sin = rotary_pos_emb - rot_dim = cos.shape[-1] - query_layer = query_layer.transpose(0, 1) - key_layer = key_layer.transpose(0, 1) - query_layer_cur = query_layer[..., :rot_dim] - key_layer_cur = key_layer[..., :rot_dim] - # ipex_llm's apply_rotary_embedding can change the origin storage, - # so query_layer will get the result directly. - torch.ops.torch_ipex.apply_rotary_embedding(query_layer_cur, sin, cos, query_layer_cur) - torch.ops.torch_ipex.apply_rotary_embedding(key_layer_cur, sin, cos, key_layer_cur) - query_layer = query_layer.transpose(0, 1) - key_layer = key_layer.transpose(0, 1) - else: - query_layer = apply_rotary_pos_emb_chatglm(query_layer, rotary_pos_emb) - key_layer = apply_rotary_pos_emb_chatglm(key_layer, rotary_pos_emb) - - query_layer = query_layer.permute(1, 2, 0, 3) - key_layer = key_layer.permute(1, 2, 0, 3) - value_layer = value_layer.permute(1, 2, 0, 3) - # query, key, value's shape: [bs, n_head/n_kv_head, seq_len, head_dim] - batch_size, _, seq_len, _ = query_layer.shape - - if kv_cache is None: - # first token - if self.multi_query_attention: - key, value = repeat_kv(key_layer, value_layer, n_head) - else: - key, value = key_layer, value_layer - - if should_split_qkv_tensor(query_layer, batch_size, n_head, seq_len): - # split second dim to block size = 8 - block_size = 8 - query_split = torch.split(query_layer, block_size, dim=1) - key_split = torch.split(key, block_size, dim=1) - value_split = torch.split(value, block_size, dim=1) - results = [] - for q, k, v in zip(query_split, key_split, value_split): - result = glm_sdpa(q, k, v, is_causal=True) - results.append(result) - context_layer = torch.cat(results, dim=1) - else: - context_layer = glm_sdpa(query_layer, key, value, is_causal=True) - context_layer = context_layer.to(query_layer.dtype) - - if use_cache: - k_cache, v_cache = init_fp8_kv_cache(batch_size, - n_kv_head, - seq_len, - head_dim, - query_layer.device) - k_cache, v_cache = append_fp8_kv_cache(k_cache, v_cache, key_layer, value_layer) - else: - k_cache, v_cache = kv_cache - k_cache = k_cache.permute(1, 2, 0, 3) - v_cache = v_cache.permute(1, 2, 0, 3) - # k_cache, v_cache's shape: [bs, n_kv_head, seq_len, head_dim] - - k_cache, v_cache = append_fp8_kv_cache(k_cache, v_cache, key_layer, value_layer) - - if attention_mask is not None: - attention_mask = ~attention_mask - attn_bias = torch.zeros(attention_mask.shape, dtype=query_layer.dtype, - device=query_layer.device) - if attention_mask.dtype == torch.bool: - attn_bias.masked_fill_(attention_mask.logical_not(), float("-inf")) - else: - attn_bias += attention_mask - else: - attn_bias = None - - if seq_len != 1: - key, value = restore_fp8_kv_cache(k_cache, v_cache, query_layer.dtype) - key, value = repeat_kv(key, value, n_head) - attn = torch.matmul(query_layer, key.transpose(2, 3)) / math.sqrt(head_dim) - if attn_bias is not None: - attn += attn_bias - attn = F.softmax(attn, dim=-1, dtype=torch.float32) - context_layer = torch.matmul(attn.to(value.dtype), value) - else: - key, value = k_cache, v_cache - import xe_addons - context_layer = xe_addons.sdp_fp8(query_layer, key, value, attn_bias) - - # context_layer's shape: [bs, n_head, seq_len, head_dim] -> [seq_len, bs, n_head * head_dim] - context_layer = context_layer.permute(2, 0, 1, 3).contiguous().view(seq_len, batch_size, -1) - - if use_cache: - kv_cache = (k_cache.permute(2, 0, 1, 3), v_cache.permute(2, 0, 1, 3)) - else: - kv_cache = None - - output = self.dense(context_layer) + qkv = self.query_key_value(hidden_states) + qkv = qkv.view(q_len, bsz, n_head + 2 * n_kv_head, head_dim) + # [seq_len, bsz, n_head, head_dim] -> [bsz, n_head, seq_len, head_dim] + qkv = qkv.permute(1, 2, 0, 3) - return output, kv_cache + query_states, key_states, value_states = qkv.split([n_head, + n_kv_head, + n_kv_head], dim=1) + kv_seq_len = key_states.shape[2] + if past_key_value is not None: + kv_seq_len += past_key_value[0].shape[2] -def chatglm2_attention_forward_8eb45c( - self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True -): - # hidden_states: [sq, b, h] - - # ================================================= - # Pre-allocate memory for key-values for inference. - # ================================================= - # ===================== - # Query, Key, and Value - # ===================== - - # Attention heads [sq, b, h] --> [sq, b, (np * 3 * hn)] - device = hidden_states.device - mixed_x_layer = self.query_key_value(hidden_states) - - if self.multi_query_attention: - (query_layer, key_layer, value_layer) = mixed_x_layer.split( - [ - self.num_attention_heads_per_partition * self.hidden_size_per_attention_head, - self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head, - self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head, - ], - dim=-1, - ) - query_layer = query_layer.view( - query_layer.size()[:-1] + (self.num_attention_heads_per_partition, - self.hidden_size_per_attention_head) - ) - key_layer = key_layer.view( - key_layer.size()[:-1] + (self.num_multi_query_groups_per_partition, - self.hidden_size_per_attention_head) - ) - value_layer = value_layer.view( - value_layer.size()[:-1] - + (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head) - ) + # IPEX-LLM OPT: fuse rope + inv_freq, position_ids = rotary_pos_emb + rot_dim = inv_freq.size(-1) * 2 + if should_use_fuse_rope(hidden_states, rotary_pos_emb[1], self.training): + import xe_addons + xe_addons.rotary_two_inplaced(inv_freq, position_ids, + query_states[..., :rot_dim], key_states[..., :rot_dim]) else: - new_tensor_shape = mixed_x_layer.size()[:-1] + (self.num_attention_heads_per_partition, - 3 * self.hidden_size_per_attention_head) - mixed_x_layer = mixed_x_layer.view(*new_tensor_shape) - - # [sq, b, np, 3 * hn] --> 3 [sq, b, np, hn] - (query_layer, key_layer, value_layer) = split_tensor_along_last_dim(mixed_x_layer, 3) - - cur_length, batch_size = query_layer.shape[0], query_layer.shape[1] - - # apply relative positional encoding (rotary embedding) - if rotary_pos_emb is not None: - if len(rotary_pos_emb) == 2 and isinstance(rotary_pos_emb, tuple): - # use_fuse_rope, see chatglm2_model_forward - cos, sin = rotary_pos_emb - rot_dim = cos.shape[-1] - query_layer = query_layer.transpose(0, 1) - key_layer = key_layer.transpose(0, 1) - query_layer_cur = query_layer[..., :rot_dim] - key_layer_cur = key_layer[..., :rot_dim] - # ipex_llm's apply_rotary_embedding can change the origin storage, - # so query_layer will get the result directly. - torch.ops.torch_ipex.apply_rotary_embedding(query_layer_cur, sin, cos, query_layer_cur) - torch.ops.torch_ipex.apply_rotary_embedding(key_layer_cur, sin, cos, key_layer_cur) - query_layer = query_layer.transpose(0, 1) - key_layer = key_layer.transpose(0, 1) - else: - query_layer = apply_rotary_pos_emb_chatglm(query_layer, rotary_pos_emb) - key_layer = apply_rotary_pos_emb_chatglm(key_layer, rotary_pos_emb) + idx_theta = torch.outer(position_ids[0].float(), + inv_freq.float()).to(hidden_states.dtype) + idx_theta = idx_theta.unsqueeze(0).unsqueeze(0) + cos = torch.cos(idx_theta).repeat_interleave(2, -1) + sin = torch.sin(idx_theta).repeat_interleave(2, -1) + q_rot, k_rot = apply_rotary_pos_emb(query_states[..., :rot_dim], key_states[..., :rot_dim], + cos, sin, position_ids, "chatglm") + query_states[..., :rot_dim] = q_rot[...] + key_states[..., :rot_dim] = k_rot[...] + + # IPEX-LLM OPT: kv cache and quantize kv + use_quantize_kv = use_quantize_kv_cache(self.query_key_value, hidden_states) + key_states, value_states = update_past_key_value( + past_key_value, key_states, value_states, + kv_seq_len, use_quantize_kv, hidden_states.device + ) + # past_key_value: [bsz, n_kv_head, seq_len, head_dim] -> [seq_len, bsz, n_kv_head, head_dim] + past_key_value = (key_states.permute(2, 0, 1, 3), + value_states.permute(2, 0, 1, 3)) if use_cache else None - if self.multi_query_attention: - if device.type == "xpu" and batch_size > 1: # use beam_search for generation. - # If batch_size > 1 on gpu, permute key/value_layer to [bs, np, sl, hn] - # to reduce memory usage. Otherwise，expend key/value_layer to [bs, nh, sl, hn]. - key_layer = key_layer.permute(1, 2, 0, 3) # [bs, np, sl, hn] - value_layer = value_layer.permute(1, 2, 0, 3) # [bs, np, sl, hn] + # IPEX-LLM OPT: sdp + attn_weights = None + if use_sdp(q_len, kv_seq_len, head_dim, query_states): + import xe_addons + if use_quantize_kv: + attn_output = xe_addons.sdp_fp8(query_states, key_states, value_states, attention_mask) else: - key_length = key_layer.size(0) - query_group_size = self.num_attention_heads_per_partition // \ - self.num_multi_query_groups_per_partition - key_layer = key_layer.permute(1, 2, 0, 3).unsqueeze(-3) # [bs, nh/k, sl, hn] - key_layer = key_layer.expand(-1, -1, query_group_size, -1, -1) - key_layer = key_layer.contiguous().view((batch_size, - self.num_attention_heads_per_partition, - key_length, - self.hidden_size_per_attention_head)) - value_layer = value_layer.permute(1, 2, 0, 3).unsqueeze(-3) # [bs, nh/k, sl, hn] - value_layer = value_layer.expand(-1, -1, query_group_size, -1, -1) - value_layer = value_layer.contiguous().view((batch_size, - self.num_attention_heads_per_partition, - key_length, - self.hidden_size_per_attention_head)) - - # adjust key and value for inference - if kv_cache is not None: - cache_k, cache_v = kv_cache - cache_k = cache_k.permute(1, 2, 0, 3) - cache_v = cache_v.permute(1, 2, 0, 3) - past_length = cache_k.size(2) - - if cache_k.stride()[1] < (past_length + cur_length) * cache_k.size(3): - max_cache_length = past_length + cur_length + KV_CACHE_ALLOC_BLOCK_LENGTH - if device.type == "xpu" and batch_size > 1: # use beam_search for generation. - # If batch_size > 1 on gpu, use init_kv_cache to avoid empty cache for ensuring - # generation correctness. - # Set the num_heads in init_kv_cache to np, ensuring that the tensors of - # new_cache_k/v and key/value_layer have the same size. - new_cache_k, new_cache_v = init_kv_cache(batch_size, - self.num_multi_query_groups_per_partition, - self.hidden_size_per_attention_head, - past_length, - max_cache_length, - dtype=query_layer.dtype, - device=device) - else: - new_cache_k, new_cache_v = extend_kv_cache(batch_size, - self.num_attention_heads_per_partition, - self.hidden_size_per_attention_head, - past_length, - max_cache_length, - dtype=query_layer.dtype, - device=device) - new_cache_k[:] = cache_k - new_cache_v[:] = cache_v - cache_k = new_cache_k - cache_v = new_cache_v - - key_layer, value_layer = append_kv_cache(cache_k, cache_v, key_layer, value_layer) - - elif use_cache: - max_cache_length = max(KV_CACHE_ALLOC_MIN_LENGTH, cur_length) \ - + KV_CACHE_ALLOC_BLOCK_LENGTH - - if device.type == "xpu" and batch_size > 1: # use beam_search for generation. - # Ensure the tensors of key/value_cache and key/value_layer have the same size. - nums_per_partition = self.num_multi_query_groups_per_partition + attn_output = xe_addons.sdp(query_states, key_states, value_states, attention_mask) + elif use_sdp_causal(q_len, kv_seq_len, head_dim, query_states, self.training): + import xe_addons + if use_quantize_kv: + attn_output = xe_addons.sdp_fp8_causal(query_states, key_states, value_states, + attention_mask) else: - nums_per_partition = self.num_attention_heads_per_partition - - key_cache, value_cache = init_kv_cache(batch_size, - nums_per_partition, - self.hidden_size_per_attention_head, - cur_length, - max_cache_length, - dtype=query_layer.dtype, - device=device) - key_cache[:] = key_layer - value_cache[:] = value_layer - key_layer = key_cache - value_layer = value_cache - - # If batch_size > 1, return tensors with shape [bs, np, sl, hn] as past_key_values. This could - # reduce memory usage as tensors are not expended to [bs, nh, sl, hn]. - # Otherwise, return views of [bs, nh, sl, hn]. - cache_key_layer = key_layer - cache_value_layer = value_layer - - if use_cache: - kv_cache = (key_layer, value_layer) + attn_output = xe_addons.sdp_causal(query_states, key_states, value_states, + attention_mask) else: - kv_cache = None - - # ================================== - # core attention computation - # ================================== - if device.type == "xpu" and batch_size > 1: # use beam_search for generation. - # If batch_size > 1, expend key/value_layer to [ns, nh, sl, bn] for - # core attention computation. - # The expanded tensors will not be returned as past_key_values. - if self.multi_query_attention: - query_group_size = self.num_attention_heads_per_partition // \ - self.num_multi_query_groups_per_partition - key_layer = key_layer.unsqueeze(-3) - key_layer = key_layer.expand(-1, -1, query_group_size, -1, -1) - save_length = key_layer.size(3) - # [bs, np, sl, hn] --> [bs, nh, sl, hn] - key_layer = key_layer.contiguous().view((batch_size, - self.num_attention_heads_per_partition, - save_length, - self.hidden_size_per_attention_head)) - value_layer = value_layer.unsqueeze(-3) - value_layer = value_layer.expand(-1, -1, query_group_size, -1, -1) - # [bs, np, sl, hn] --> [bs, nh, sl, hn] - value_layer = value_layer.contiguous().view((batch_size, - self.num_attention_heads_per_partition, - save_length, - self.hidden_size_per_attention_head)) - - context_layer = core_attn_forward_8eb45c(query_layer, key_layer, value_layer, attention_mask) - - # ================= - # Output. [sq, b, h] - # ================= - - output = self.dense(context_layer) - - return output, (cache_key_layer.permute(2, 0, 1, 3), cache_value_layer.permute(2, 0, 1, 3)) - + if use_quantize_kv: + key_states, value_states = restore_fp8_kv_cache(key_states, value_states, + query_states.dtype) + # repeat k/v heads if n_kv_heads < n_heads + key_states = repeat_kv(key_states, n_head // n_kv_head) + value_states = repeat_kv(value_states, n_head // n_kv_head) + + attn_weights = torch.matmul(query_states, + key_states.transpose(2, 3)) / math.sqrt(head_dim) + if attention_mask is not None: + attn_weights = attn_weights + attention_mask + attn_weights = torch.nn.functional.softmax(attn_weights, dim=-1, + dtype=torch.float32).to(value_states.dtype) + attn_output = torch.matmul(attn_weights, value_states) -def core_attn_forward_8eb45c(query_layer, key_layer, value_layer, attention_mask): - query_layer = query_layer.permute(1, 2, 0, 3) - L, S = query_layer.shape[2], key_layer.shape[2] - batch_size, n_head, seq_len, head_dim = query_layer.shape - if attention_mask is None and L == S: - if should_split_qkv_tensor(query_layer, batch_size, n_head, seq_len): - # split second dim to block size = 8 - block_size = 8 - query_layer = query_layer.to(key_layer.dtype) - query_split = torch.split(query_layer, block_size, dim=1) - key_split = torch.split(key_layer, block_size, dim=1) - value_split = torch.split(value_layer, block_size, dim=1) - results = [] - for q, k, v in zip(query_split, key_split, value_split): - result = glm_sdpa(q, k, v, is_causal=True) - results.append(result) - context_layer = torch.cat(results, dim=1) - else: - context_layer = glm_sdpa(query_layer, - key_layer, - value_layer, - is_causal=True) - else: - context_layer = glm_sdpa(query_layer, - key_layer, - value_layer, - attention_mask) - context_layer = context_layer.permute(2, 0, 1, 3) - new_context_layer_shape = context_layer.size()[:-2] + (-1,) - context_layer = context_layer.reshape(*new_context_layer_shape) + # context_layer's shape: [bsz, n_head, seq_len, head_dim] -> [seq_len, bsz, n_head * head_dim] + attn_output = attn_output.permute(2, 0, 1, 3).contiguous().view(q_len, bsz, n_head * head_dim) + output = self.dense(attn_output) - return context_layer + return output, past_key_value diff --git a/python/llm/src/ipex_llm/transformers/models/utils.py b/python/llm/src/ipex_llm/transformers/models/utils.py index 449d331ada9..48a6d1b8345 100644 --- a/python/llm/src/ipex_llm/transformers/models/utils.py +++ b/python/llm/src/ipex_llm/transformers/models/utils.py @@ -186,7 +186,7 @@ def apply_rotary_pos_emb(q, k, cos, sin, position_ids, model_family): q_embed = (q * cos) + (rotate_half(q) * sin) k_embed = (k * cos) + (rotate_half(k) * sin) return q_embed, k_embed - elif model_family == "gptj": + elif model_family in ["gptj", "chatglm"]: q_embed = (q * cos) + (rotate_every_two(q) * sin) k_embed = (k * cos) + (rotate_every_two(k) * sin) return q_embed, k_embed