from transformers import Olmo2Model, Olmo2ForCausalLM, AutoTokenizer, logging from transformers.models.auto.modeling_auto import MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES from transformers.modeling_outputs import ( CausalLMOutputWithPast, BaseModelOutputWithPast, ) import numpy as np import math from torch import nn import pandas as pd from transformers.cache_utils import Cache, DynamicCache, StaticCache from dataclasses import dataclass # Olmo2 from transformers.models.olmo2.modeling_olmo2 import Olmo2RotaryEmbedding, Olmo2Attention, Olmo2MLP, Olmo2RMSNorm, apply_rotary_pos_emb, eager_attention_forward, Olmo2DecoderLayer from transformers.models.olmo2.configuration_olmo2 import Olmo2Config from transformers.processing_utils import Unpack from transformers.modeling_flash_attention_utils import FlashAttentionKwargs from transformers.utils import LossKwargs from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS from torch.nn.functional import cosine_similarity import pdb from dataset import * import torch import torch.nn.functional as F import functools import torch.distributed as dist from torch.distributed.fsdp import ( FullyShardedDataParallel as FSDP, MixedPrecision, BackwardPrefetch, ShardingStrategy, FullStateDictConfig, StateDictType, ) from torch.distributed.fsdp.wrap import ( transformer_auto_wrap_policy, enable_wrap, wrap, ) from functools import partial from torch.utils.data import DataLoader from pathlib import Path from typing import Type, List, Optional, Tuple, Union, Callable, Dict, Any ############ specially for generate() ################# import inspect from transformers.generation.configuration_utils import ( NEED_SETUP_CACHE_CLASSES_MAPPING, QUANT_BACKEND_CLASSES_MAPPING, GenerationConfig, GenerationMode, ) from transformers.generation.logits_process import LogitsProcessorList from transformers.generation.stopping_criteria import StoppingCriteriaList from transformers.integrations.deepspeed import is_deepspeed_zero3_enabled from transformers.integrations.fsdp import is_fsdp_managed_module from transformers.generation.utils import ( is_torchdynamo_compiling, ModelOutput, GenerateDecoderOnlyOutput, GenerateEncoderDecoderOutput, GenerateBeamDecoderOnlyOutput, GenerateBeamEncoderDecoderOutput, GreedySearchDecoderOnlyOutput, ContrastiveSearchDecoderOnlyOutput, SampleDecoderOnlyOutput, ContrastiveSearchEncoderDecoderOutput, GreedySearchEncoderDecoderOutput, SampleEncoderDecoderOutput, BeamSearchDecoderOnlyOutput, BeamSampleDecoderOnlyOutput, BeamSearchEncoderDecoderOutput, BeamSampleEncoderDecoderOutput, GreedySearchOutput, SampleOutput, BeamSearchOutput, BeamSampleOutput, ContrastiveSearchOutput, GenerateNonBeamOutput, GenerateBeamOutput, GenerateOutput) from transformers.generation.stopping_criteria import ( ConfidenceCriteria, EosTokenCriteria, MaxLengthCriteria, MaxTimeCriteria, StoppingCriteria, StoppingCriteriaList, StopStringCriteria, ) from transformers.generation.stopping_criteria import STOPPING_CRITERIA_INPUTS_DOCSTRING from transformers.pytorch_utils import isin_mps_friendly from transformers.utils import add_start_docstrings class EosTokenCriteriaForSemiNAT(StoppingCriteria): """ This class can be used to stop generation whenever the "end-of-sequence" token is generated. By default, it uses the `model.generation_config.eos_token_id`. Args: eos_token_id (`Union[int, List[int], torch.Tensor]`): The id(s) of the *end-of-sequence* token. """ def __init__(self, eos_token_id: Union[int, List[int], torch.Tensor]): if not isinstance(eos_token_id, torch.Tensor): if isinstance(eos_token_id, int): eos_token_id = [eos_token_id] eos_token_id = torch.tensor(eos_token_id) self.eos_token_id = eos_token_id @add_start_docstrings(STOPPING_CRITERIA_INPUTS_DOCSTRING) def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, last_k: int, **kwargs) -> torch.BoolTensor: # pdb.set_trace() # if torch.any(input_ids == 100257): # pdb.set_trace() self.eos_token_id = self.eos_token_id.to(input_ids.device) token_is_eos = isin_mps_friendly(input_ids[:, -last_k:], self.eos_token_id) is_done = torch.any(token_is_eos, dim=1) return is_done ############ specially for generate() ################# class KwargsForCausalLM(FlashAttentionKwargs, LossKwargs): ... @dataclass class ModelOutputWithPastForSemiNAT(BaseModelOutputWithPast): chunk_hidden_state: torch.FloatTensor = None length_ground_truth: Optional[torch.FloatTensor] = None length_logits: Optional[torch.FloatTensor] = None position_embeddings: Optional[torch.FloatTensor] = None # ? nar_hidden_state: torch.FloatTensor = None # ? past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None hidden_states: Optional[Tuple[torch.FloatTensor, ...]] = None attentions: Optional[Tuple[torch.FloatTensor, ...]] = None class TwoLayerMLP(nn.Module): def __init__(self, hidden_size: int, dropout_rate: float = 0.1): """ 初始化两层MLP，支持任意批处理维度 参数: hidden_size (int): 隐藏层维度 dropout_rate (float): dropout比率，默认0.1 """ super().__init__() self.fc1 = nn.Linear(hidden_size, 4 * hidden_size) # 第一层将维度扩大4倍 self.fc2 = nn.Linear(4 * hidden_size, hidden_size) # 第二层将维度恢复 self.dropout = nn.Dropout(p=dropout_rate) self.activation = nn.GELU() # 使用GELU激活函数 def forward(self, x: torch.Tensor) -> torch.Tensor: """ 前向传播，支持任意批处理维度 参数: x (torch.Tensor): 输入张量，形状为 (..., hidden_size)，支持任意前置维度 返回: torch.Tensor: 输出张量，形状与输入相同 """ # 获取原始形状 original_shape = x.shape hidden_size = original_shape[-1] # 将输入重塑为2D: (batch_size, hidden_size)，其中batch_size包含了所有前置维度 x_2d = x.view(-1, hidden_size) # pdb.set_trace() # 第一层：线性变换 -> 激活函数 -> dropout x_2d = self.fc1(x_2d) x_2d = self.activation(x_2d) x_2d = self.dropout(x_2d) # 第二层：线性变换 x_2d = self.fc2(x_2d) # pdb.set_trace() # 恢复原始形状 x = x_2d.view(*original_shape) # pdb.set_trace() return x class Olmo2ConfigForSemiNAT(Olmo2Config): def __init__(self, chunk_size_limit: int = 5, decoder_layers: int = 1, encoder_layer: int = 1, mlp: bool = False, position_embedding_type: str = "absolute",attn_implementation: str = "sdpa", length_loss_type: str = "ce", **kwargs): super().__init__(**kwargs) self.chunk_size_limit = chunk_size_limit self.decoder_layers = decoder_layers self.encoder_layer = encoder_layer self.mlp = mlp self.position_embedding_type = position_embedding_type self._attn_implementation = attn_implementation self.length_loss_type = length_loss_type # pdb.set_trace() class Olmo2AttentionForSemiNAT(nn.Module): """Multi-headed attention from 'Attention Is All You Need' paper""" def __init__(self, config: Olmo2ConfigForSemiNAT, layer_idx: Optional[int] = None, is_causal: bool = True): super().__init__() self.config = config self.layer_idx = layer_idx self.head_dim = getattr( config, "head_dim", config.hidden_size // config.num_attention_heads) self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads self.scaling = self.head_dim**-0.5 self.attention_dropout = config.attention_dropout self.is_causal = is_causal self.q_proj = nn.Linear(config.hidden_size, config.num_attention_heads * self.head_dim, bias=config.attention_bias) self.k_proj = nn.Linear(config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias) self.v_proj = nn.Linear(config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias) self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=config.attention_bias) self.q_norm = Olmo2RMSNorm(config.num_attention_heads * self.head_dim, config.rms_norm_eps) self.k_norm = Olmo2RMSNorm(config.num_key_value_heads * self.head_dim, config.rms_norm_eps) def forward( self, hidden_states: torch.Tensor, position_embeddings: Tuple[torch.Tensor, torch.Tensor], attention_mask: Optional[torch.Tensor], past_key_value: Optional[Cache] = None, cache_position: Optional[torch.LongTensor] = None, **kwargs, ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: input_shape = hidden_states.shape[:-1] hidden_shape = (*input_shape, -1, self.head_dim) query_states = self.q_norm(self.q_proj(hidden_states)) key_states = self.k_norm(self.k_proj(hidden_states)) value_states = self.v_proj(hidden_states) query_states = query_states.view(hidden_shape).transpose(1, 2) key_states = key_states.view(hidden_shape).transpose(1, 2) value_states = value_states.view(hidden_shape).transpose(1, 2) if position_embeddings is not None: cos, sin = position_embeddings query_states, key_states = apply_rotary_pos_emb( query_states, key_states, cos, sin) if past_key_value is not None: # sin and cos are specific to RoPE models; cache_position needed for the static cache cache_kwargs = { "sin": sin, "cos": cos, "cache_position": cache_position } key_states, value_states = past_key_value.update( key_states, value_states, self.layer_idx, cache_kwargs) # attention_interface: Callable = eager_attention_forward # pdb.set_trace() # if self.config._attn_implementation != "eager": # if self.config._attn_implementation == "sdpa" and kwargs.get( # "output_attentions", False): # logger.warning_once( # "`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to " # 'eager attention. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.' # ) # else: # attention_interface = ALL_ATTENTION_FUNCTIONS[ # self.config._attn_implementation] attention_interface: Callable = ALL_ATTENTION_FUNCTIONS["sdpa"] #针对encoder和decoder的新设定 # pdb.set_trace() attn_output, attn_weights = attention_interface( self, query_states, key_states, value_states, attention_mask, dropout=0.0 if not self.training else self.attention_dropout, scaling=self.scaling, is_causal=self.is_causal, **kwargs, ) # pdb.set_trace() attn_output = attn_output.reshape(*input_shape, -1).contiguous() attn_output = self.o_proj(attn_output) return attn_output, attn_weights class Olmo2DecoderLayerForSemiNAT(nn.Module): def __init__( self, config: Olmo2ConfigForSemiNAT, layer_idx: int, is_causal: bool = True, ): super().__init__() self.hidden_size = config.hidden_size # pdb.set_trace() self.self_attn = Olmo2AttentionForSemiNAT(config=config, layer_idx=layer_idx, is_causal=is_causal) self.mlp = Olmo2MLP(config) self.post_attention_layernorm = Olmo2RMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.post_feedforward_layernorm = Olmo2RMSNorm(config.hidden_size, eps=config.rms_norm_eps) # pdb.set_trace() def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, past_key_value: Optional[Cache] = None, output_attentions: Optional[bool] = False, use_cache: Optional[bool] = False, cache_position: Optional[torch.LongTensor] = None, position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, **kwargs, ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]: residual = hidden_states # pdb.set_trace() # Self Attention hidden_states, self_attn_weights = self.self_attn( hidden_states=hidden_states, attention_mask=attention_mask, position_ids=position_ids, past_key_value=past_key_value, output_attentions=output_attentions, use_cache=use_cache, cache_position=cache_position, position_embeddings=position_embeddings, **kwargs, ) # pdb.set_trace() hidden_states = self.post_attention_layernorm(hidden_states) hidden_states = residual + hidden_states # Fully Connected residual = hidden_states hidden_states = self.mlp(hidden_states) hidden_states = self.post_feedforward_layernorm(hidden_states) hidden_states = residual + hidden_states outputs = (hidden_states, ) if output_attentions: outputs += (self_attn_weights, ) return outputs class NATEncoderForSemiNAT(nn.Module): def __init__(self, config: Olmo2ConfigForSemiNAT, num_layer: int = 1): super().__init__() self.num_layer = num_layer self.encoder_layers = nn.ModuleList([ Olmo2DecoderLayerForSemiNAT(config, layer_idx) #check下需不需要is causal false，但attn_mask优先级高于is_causal for layer_idx in range(self.num_layer) ]) def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, past_key_value: Optional[Cache] = None, output_attentions: Optional[bool] = False, use_cache: Optional[bool] = False, cache_position: Optional[torch.LongTensor] = None, position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]: # pdb.set_trace() for layer in self.encoder_layers: outputs = layer(hidden_states=hidden_states, output_attentions=output_attentions, position_embeddings=position_embeddings, attention_mask=attention_mask) hidden_states = outputs[0] # pdb.set_trace() # only the last layer attn_weights and present_key_value are stored # mean pool the hidden states across sequence (chunk) # hidden_states = torch.mean(hidden_states, dim=1) return hidden_states class NATDecoderForSemiNAT(nn.Module): def __init__(self, config: Olmo2ConfigForSemiNAT, num_layer: int = 1): super().__init__() self.num_layer = num_layer self.decoder_layers = nn.ModuleList([ Olmo2DecoderLayerForSemiNAT(config, layer_idx, False) for layer_idx in range(self.num_layer) ]) def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, past_key_value: Optional[Cache] = None, output_attentions: Optional[bool] = False, use_cache: Optional[bool] = False, cache_position: Optional[torch.LongTensor] = None, position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]: for layer in self.decoder_layers: # pdb.set_trace() outputs = layer(hidden_states=hidden_states, attention_mask=attention_mask, output_attentions=output_attentions, position_embeddings=position_embeddings) hidden_states = outputs[0] return hidden_states class Olmo2ModelForSemiNAT(Olmo2Model): def __init__(self, config): super().__init__(config) self.layers = nn.ModuleList([ Olmo2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers) ]) self.decoder = NATDecoderForSemiNAT(config, config.decoder_layers) self.encoder = NATEncoderForSemiNAT(config, config.encoder_layer) # pdb.set_trace() self.chunk_size_limit = config.chunk_size_limit self.norm = Olmo2RMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.rotary_emb = Olmo2RotaryEmbedding(config=config) self.pos_encoder = AbsolutePositionalEncoding(config.hidden_size) self.gradient_checkpointing = False self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx) self.length_predictor = nn.Linear(config.hidden_size, self.chunk_size_limit) self.mlp = config.mlp if self.mlp: self.linear_projection = TwoLayerMLP(config.hidden_size) # pdb.set_trace() self.position_embedding_type = config.position_embedding_type def forward( self, input_ids: torch.LongTensor = None, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, slice_pos: torch.Tensor = None, past_key_values: Optional[Union[Cache, List[torch.FloatTensor]]] = None, inputs_embeds: Optional[torch.FloatTensor] = None, use_cache: Optional[bool] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, cache_position: Optional[torch.LongTensor] = None, inference: Optional[bool] = None, padding: Optional[torch.Tensor] = None, is_prefill: Optional[bool] = False, **flash_attn_kwargs: Unpack[FlashAttentionKwargs], ) -> Union[Tuple, CausalLMOutputWithPast]: output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions output_hidden_states = (output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states) use_cache = use_cache if use_cache is not None else self.config.use_cache return_dict = return_dict if return_dict is not None else self.config.use_return_dict if (input_ids is None) ^ (inputs_embeds is not None): raise ValueError( "You must specify exactly one of input_ids or inputs_embeds") if self.gradient_checkpointing and self.training and use_cache: logger.warning_once( "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`." ) use_cache = False if inputs_embeds is None: inputs_embeds = self.embed_tokens(input_ids) # pdb.set_trace() if use_cache and past_key_values is None: past_key_values = DynamicCache() if cache_position is None: past_seen_tokens = past_key_values.get_seq_length( ) if past_key_values is not None else 0 cache_position = torch.arange(past_seen_tokens, past_seen_tokens + inputs_embeds.shape[1], device=inputs_embeds.device) if position_ids is None: position_ids = cache_position.unsqueeze(0) if inference is not None: position_ids = cache_position.unsqueeze(0) position_embeddings = self.rotary_emb(inputs_embeds, position_ids) all_hidden_states = () if output_hidden_states else None all_self_attns = () if output_attentions else None next_decoder_cache = None max_chunk_num = (slice_pos != -1).sum(dim=1).max() # pdb.set_trace() ################################ 并行处理 ################################# # pdb.set_trace() # 这里attention_mask没有用，因为encoder没有attention层 length_ground_truth = None if not inference or is_prefill: M_avg, attn_mask, length_ground_truth, chunk_attention_mask, slice_num = self.build_slice_matrix(input_ids,slice_pos) # torch.Size([1, 111, 512]) encoded_input = self.encoder(inputs_embeds,position_embeddings=position_embeddings,attention_mask=attn_mask) # torch.Size([1, 512, 2048]) # pdb.set_trace() M_avg = M_avg.contiguous() encoded_input = encoded_input.contiguous() M_avg = M_avg.to(torch.bfloat16) encoded_input = encoded_input.to(torch.bfloat16) chunk_inputs_embeds = torch.matmul(M_avg, encoded_input) accumu_num = sum(slice_num)-encoded_input.shape[0] chunk_inputs_embeds = chunk_inputs_embeds[:, :max_chunk_num, :] chunk_attention_mask = chunk_attention_mask[:, :max_chunk_num] length_ground_truth = length_ground_truth[:,:max_chunk_num] chunk_position_ids = position_ids[:,:max_chunk_num] chunk_cache_position = cache_position[:max_chunk_num] # pdb.set_trace() else: encoded_input = self.encoder(inputs_embeds[:,position_ids.squeeze(0)],position_embeddings=position_embeddings) chunk_inputs_embeds = torch.mean(encoded_input, dim=1).unsqueeze(0) # pdb.set_trace() chunk_cache_position = torch.searchsorted(slice_pos.squeeze(0), cache_position - 1, right=True)[-1].unsqueeze(0) #prefill之后，更新下chunk的cache_position chunk_attention_mask = torch.ones(1,cache_position[0]) chunk_position_ids = chunk_cache_position.unsqueeze(0) ################################ 并行处理 ################################# ################################ 串行处理 ################################# # initialize chunk inputs as embedding of [pad] # pad_token_id = padding # batch_size, seq_len, hidden_size = inputs_embeds.shape # pad_embedding = self.embed_tokens( # torch.tensor([pad_token_id]).to(inputs_embeds.device)) # 1, 2048 # # pdb.set_trace() # chunk_inputs_embeds = pad_embedding.expand( # batch_size, max_chunk_num, hidden_size).clone().to( # inputs_embeds.device) # length_ground_truth = [] # chunk_attention_mask = [] # chunk_labels = [] # # max_chunk_num = 0 # accumu_num = 0 # slice_nums = [] # for b in range(batch_size): # slice_num = 0 # start_position = 0 # slice_length = [] # for i in range(seq_len): # cut = slice_pos[b, i].item() # 获取切分点 # if cut == -1: # 如果切分点为 -1，表示不切分 # pass # else: # cut += 1 # +1表示在后面切一刀 # chunk_inputs_embeds[b, i] = self.encoder( # inputs_embeds[b, start_position:cut].unsqueeze(0), # position_embeddings=tuple( # tensor[0, 0:cut - # start_position, :].unsqueeze(0) # for tensor in position_embeddings)) # slice_num += 1 # slice_length.append(cut - start_position) # if cut - start_position > 10 or cut - start_position < 0: # pdb.set_trace() # start_position = cut # 更新切分起点 # slice_nums.append(slice_num) # 每个样本的 chunk 数量 # # max_chunk_num = max(max_chunk_num, slice_num) # 不用这个，直接用累计的chunk num # accumu_num += slice_num # chunk_attention_mask.append( # torch.tensor([1] * slice_num + [0] * # (seq_len - slice_num)).unsqueeze( # 0)) # 1表示切分，0表示不切分 # length_ground_truth.append( # torch.tensor(slice_length + [-100] * # (seq_len - slice_num)).unsqueeze(0)) # -100表示不切分 # accumu_num -= batch_size # # pdb.set_trace() # chunk_attention_mask = torch.cat(chunk_attention_mask, dim=0).to( # inputs_embeds.device) # torch.Size([1, 256]) bs * length # length_ground_truth = torch.cat(length_ground_truth, # dim=0).to(inputs_embeds.device) ################################ 串行处理 ################################# # 取最长chunk长度裁剪，加速计算 # pdb.set_trace() chunk_position_embeddings = self.rotary_emb( chunk_inputs_embeds, chunk_position_ids ) # tuple, 第一个元素为 torch.Size([1, 256, 128])，最后一个维度是 hidden_size / head ， cos 和 sin 各 64 维 hidden_states = chunk_inputs_embeds # bs * max_chunk_num * hidden_size # pdb.set_trace() # inference待check # if inference is not None: # mask_bool = chunk_attention_mask.bool() # chunk_inputs_embeds = chunk_inputs_embeds[mask_bool.unsqueeze( # -1).expand_as(chunk_inputs_embeds)].view( # chunk_inputs_embeds.size(0), -1, # chunk_inputs_embeds.size(2)) # chunk_attention_mask = chunk_attention_mask[mask_bool].view( # chunk_attention_mask.size(0), -1) # pdb.set_trace() # chunk_inputs_embeds = chunk_inputs_embeds[:, # chunk_cache_position, :] # chunk_attention_mask = chunk_attention_mask[:, # chunk_cache_position] # hidden_states = chunk_inputs_embeds causal_mask = self._update_causal_mask(chunk_attention_mask, chunk_inputs_embeds, chunk_cache_position, past_key_values, output_attentions) # pdb.set_trace() for decoder_layer in self.layers: if output_hidden_states: all_hidden_states += (hidden_states, ) if self.gradient_checkpointing and self.training: layer_outputs = self._gradient_checkpointing_func( decoder_layer.__call__, hidden_states, causal_mask, position_ids, past_key_values, output_attentions, use_cache, chunk_cache_position, chunk_position_embeddings, ) else: layer_outputs = decoder_layer( hidden_states, attention_mask=causal_mask, position_ids=position_ids, past_key_value=past_key_values, output_attentions=output_attentions, use_cache=use_cache, cache_position=chunk_cache_position, position_embeddings=chunk_position_embeddings, **flash_attn_kwargs, ) hidden_states = layer_outputs[0] if output_attentions: all_self_attns += (layer_outputs[1], ) # pdb.set_trace() # add hidden states from the last decoder layer if output_hidden_states: all_hidden_states += (hidden_states, ) hidden_states = self.norm( hidden_states) # bs * max_chunk_num * hidden_size 所有chunk的hidden next_cache = next_decoder_cache if use_cache else None # DynamicCache() # if return_legacy_cache: # next_cache = next_cache.to_legacy_cache() # 算长度预测loss self.length_predictor = self.length_predictor.to( hidden_states.device).to(hidden_states.dtype) #这里强行变成了bf16，因为训练是这个 length_logits = self.length_predictor( hidden_states.to( hidden_states.device)) # bs * length * chunk_size_limit # pdb.set_trace() nar_hidden_states = None if inference is None: # NAR decoder bs, length, hidden_size = hidden_states.size() assert length == max_chunk_num # shape: (bs * max_chunk_num) * chunk_size_limit * hidden_size # try: # nat_input_embeddings = torch.zeros( # accumu_num, self.chunk_size_limit, # hidden_size).to(hidden_states.device).to(hidden_states.dtype) # except: # pdb.set_trace() # nat_attention_mask = torch.zeros( # accumu_num, self.chunk_size_limit).to(hidden_states.device).to( # hidden_states.dtype) # tot_chunk_num = 0 nat_input_embeddings, nat_attention_mask = self.repeat_with_limit_and_pad( hidden_states, length_ground_truth, self.chunk_size_limit, skip_val=-100) if self.mlp: nat_input_embeddings = self.linear_projection(nat_input_embeddings) # pdb.set_trace() # for b in range(bs): # for i in range(slice_num[b]): # # slice_nums[b] 是每个样本的 chunk 数量 # # length_ground_truth[b] 是每个样本的真实长度 # # copy length_ground_truth 份的 hidden_states 到 nat_input_embeddings # if length_ground_truth[b, i + 1] != -100: # # pdb.set_trace() # nat_input_embeddings[ # tot_chunk_num, :length_ground_truth[ # b, i + # 1], :] = hidden_states[b, i:i + 1, :].expand( # length_ground_truth[b, i + 1], hidden_size) # nat_attention_mask[tot_chunk_num, :length_ground_truth[ # b, i + 1]] = torch.tensor( # [1] * length_ground_truth[b, i + 1]) # tot_chunk_num += 1 # # pdb.set_trace() # else: # break # pdb.set_trace() # 处理attention mask_nat_attention_mask = self.nat_prepare_4d_full_attention_mask_without_causal( attention_mask=nat_attention_mask, dtype=nat_attention_mask.dtype, device=nat_attention_mask.device) # pdb.set_trace() self.decoder = self.decoder.to(dtype=nat_input_embeddings.dtype) if self.position_embedding_type == "relative": nar_chunk_position = torch.arange( 0, self.chunk_size_limit).unsqueeze(0).repeat( accumu_num, 1).to(hidden_states.device) pos = self.rotary_emb(nat_attention_mask, nar_chunk_position) elif self.position_embedding_type == "absolute": nat_input_embeddings = self.pos_encoder(nat_input_embeddings) # 加上绝对位置编码 pos = None # pdb.set_trace() nar_hidden_states = self.decoder( nat_input_embeddings, attention_mask=mask_nat_attention_mask, #改下padding mask # attention_mask=None, position_embeddings=pos, output_attentions=output_attentions, use_cache=use_cache, cache_position=None, ) nar_hidden_states = self.norm( nar_hidden_states) # pdb.set_trace() return ModelOutputWithPastForSemiNAT( chunk_hidden_state=hidden_states, length_ground_truth=length_ground_truth, length_logits=length_logits, position_embeddings=position_embeddings, nar_hidden_state=nar_hidden_states, past_key_values=next_cache, hidden_states=all_hidden_states, attentions=all_self_attns, ) # @staticmethod # def nat_prepare_4d_full_attention_mask_without_causal( # self, # attention_mask: torch.Tensor, # dtype: torch.dtype, # device: torch.device, # ) -> torch.Tensor: # """ # 构造一个非 causal 的 full attention mask，仅遮挡 padding token。 # Args: # attention_mask (torch.Tensor): (batch_size, seq_len) 中 1 表示有效 token，0 表示 padding。 # dtype (torch.dtype): 生成的 mask 的数据类型（通常为 torch.float32/bfloat16）。 # device (torch.device): mask 所在设备。 # Returns: # torch.Tensor: shape = (batch_size, 1, seq_len, seq_len)，非 padding token 两两可见，padding 被遮挡。 # """ # if attention_mask.dim() != 2: # raise ValueError("Expected 2D attention_mask of shape (batch_size, seq_len)") # batch_size, seq_len = attention_mask.shape # attention_mask = attention_mask.to(dtype=torch.float32) # 强制 float32 再做广播逻辑 # attention_mask = attention_mask.to(device) # # outer product: only keep positions where both query and key are valid (1 * 1 = 1) # visible_mask = attention_mask[:, None, :, None] * attention_mask[:, None, None, :] # (bs, 1, seq_len, seq_len) # # 转为 additive mask：0 -> 0.0, 1 -> -inf（被遮住的位置是 -inf） # min_dtype = torch.finfo(dtype).min # full_attention_mask = (1.0 - visible_mask) * min_dtype # 有效区域是 0.0，其他是 -inf # return full_attention_mask.to(dtype=dtype) # def nat_prepare_4d_full_attention_mask_no_masking( # self, # attention_mask: torch.Tensor, # (bs, L)，此处不会被使用 # dtype: torch.dtype, # torch.float32/bfloat16 # device: torch.device, # mask_val: float = -1e4, # 不会被使用 # ) -> torch.Tensor: # """ # 构造完全互看的 attention mask，包括 padding token。 # - 所有 query 可以看所有 key； # - additive mask 全为 0（无任何遮挡）； # 返回 shape = (bs, 1, L, L) # """ # if attention_mask.dim() != 2: # raise ValueError( # "Expected 2-D attention_mask with shape (batch, seq_len)") # bs, L = attention_mask.shape # additive_mask = torch.zeros((bs, 1, L, L), dtype=dtype, # device=device) # 全 0，代表全可见 # return additive_mask def repeat_with_limit_and_pad(self, x: torch.Tensor, repeat_counts: torch.Tensor, chunk_limit: int, skip_val: int = -100): """ 对 x 中的每个位置复制若干次（最多 chunk_limit 次），不足则 padding，跳过 repeat=-100 的项。 参数： - x: Tensor of shape (bs, length, hidden) - repeat_counts: Tensor of shape (bs, length)，每个位置的复制次数，-100 表示跳过 - chunk_limit: int，每个位置最多复制的次数，不足则 padding - skip_val: int，跳过标记值，默认 -100 返回： - Tensor of shape (chunk_num, chunk_limit, hidden) """ bs, length, hidden = x.shape device = x.device x = x[:,:-1,:] repeat_counts = repeat_counts[:,1:] # Step 1: 展平 & 过滤有效位置 x_flat = x.reshape(-1, hidden) # (bs * length, hidden) repeat_flat = repeat_counts.reshape(-1) # (bs * length,) valid_mask = repeat_flat != skip_val x_valid = x_flat[valid_mask] # (chunk_num, hidden) repeat_valid = repeat_flat[valid_mask].clamp_max(chunk_limit) # (chunk_num,) # Step 2: 扩展向量 # chunk_num = x_valid.size(0) repeated = x_valid.unsqueeze(1).expand(-1, chunk_limit, -1) # (chunk_num, chunk_limit, hidden) # Step 3: 构造 mask，并乘以 mask 进行 padding range_k = torch.arange(chunk_limit, device=device).unsqueeze(0) # (1, chunk_limit) mask = (range_k < repeat_valid.unsqueeze(1)).unsqueeze(-1) # (chunk_num, chunk_limit, 1) # Step 4: 应用 mask，padding out = repeated * mask # masked 填 0 mask = mask.squeeze(-1).to(x.dtype) # pdb.set_trace() return out, mask # shape: (chunk_num, chunk_limit, hidden) # def build_slice_matrix(self, slice_pos: torch.Tensor) -> torch.Tensor: # bs, num_slices = slice_pos.shape # seq_len = num_slices # # 替换 -1 为 0 用于 prev 计算 # slice_pos_clipped = slice_pos.clone() # slice_pos_clipped[slice_pos_clipped == -1] = 0 # # prevs (a) 和 currents (b) # prevs = torch.cat([ # torch.zeros((bs,1), device=slice_pos.device, dtype=slice_pos.dtype), # slice_pos_clipped[:, :-1] + 1 # ], dim=1) # currents = slice_pos_clipped + 1 # # valid mask # valid_mask = (slice_pos != -1) # lengths = currents - prevs # (bs, num_slices) # lengths[lengths <= 0] = -100 # 将0元素替换为-100 # # 统计每行非-100元素个数 # slice_num = (lengths != -100).sum(dim=1).tolist() # 每行非-100元素个数 # # 生成chunk_mask # chunk_mask = torch.zeros_like(lengths, dtype=torch.long) # for i in range(lengths.size(0)): # chunk_mask[i, :slice_num[i]] = 1 # 前slice_num[i]个元素置1 # values = torch.zeros_like(lengths, dtype=torch.float) # values[valid_mask] = 1.0 / lengths[valid_mask] # chunk_nums = valid_mask.sum(dim=1) # (bs,) # max_chunk_num = chunk_nums.max().item() # # 初始化输出 # M = torch.zeros((bs, max_chunk_num, seq_len), device=slice_pos.device) # # 遍历 batch 填充 # for b in range(bs): # a_b = prevs[b] # (num_slices,) # b_b = currents[b] # (num_slices,) # v_b = values[b] # (num_slices,) # for i in range(num_slices): # if not valid_mask[b, i]: # continue # a = a_b[i].item() # b_ = b_b[i].item() # if b_ > a: # M[b, i, a:b_] = v_b[i] # return M, lengths, chunk_mask, slice_num def build_slice_matrix(self, input_ids, slice_pos: torch.Tensor): bs, num_slices = slice_pos.shape seq_len = input_ids.size(1) # 替换 -1 为 0 用于 prev 计算 slice_pos_clipped = slice_pos.clone() slice_pos_clipped[slice_pos_clipped == -1] = 0 # prevs (a) 和 currents (b) prevs = torch.cat([ torch.zeros((bs, 1), device=slice_pos.device, dtype=slice_pos.dtype), slice_pos_clipped[:, :-1] + 1 ], dim=1) currents = slice_pos_clipped + 1 # valid mask valid_mask = (slice_pos != -1) lengths = currents - prevs # (bs, num_slices) lengths[lengths <= 0] = -100 # invalid values # 每行非 -100 元素个数 slice_num = (lengths != -100).sum(dim=1).tolist() # chunk mask chunk_mask = torch.zeros_like(lengths, dtype=torch.long) for i in range(lengths.size(0)): chunk_mask[i, :slice_num[i]] = 1 values = torch.zeros_like(lengths, dtype=torch.float) values[valid_mask] = 1.0 / lengths[valid_mask] chunk_nums = valid_mask.sum(dim=1) max_chunk_num = chunk_nums.max().item() # 初始化输出矩阵 M M = torch.zeros((bs, max_chunk_num, seq_len), device=slice_pos.device) # 初始化 attention mask (bs, seq_len, seq_len)，默认全部 mask 掉（True） # attn_mask = torch.zeros((bs, 1, seq_len, seq_len), dtype=torch.bool, device=slice_pos.device) # 让padding看见自己 attn_mask = torch.eye(seq_len, dtype=torch.bool, device=slice_pos.device) # shape [seq_len, seq_len] attn_mask = attn_mask.unsqueeze(0).unsqueeze(0).expand(bs, 1, seq_len, seq_len) # [bs, 1, seq_len, seq_len] # 遍历填充 M 和 attention mask for b in range(bs): a_b = prevs[b] b_b = currents[b] v_b = values[b] for i in range(num_slices): if not valid_mask[b, i]: continue a = a_b[i].item() b_ = b_b[i].item() if b_ > a: # 填充 chunk average matrix M[b, i, a:b_] = v_b[i] # 更新 attention mask，chunk 内不 mask（False） attn_mask[b, :, a:b_, a:b_] = True # pdb.set_trace() return M, attn_mask, lengths, chunk_mask, slice_num def nat_prepare_4d_full_attention_mask_without_causal( self, attention_mask: torch.Tensor, # (bs, L) 1=real, 0=pad dtype: torch.dtype, # torch.float32/bfloat16 device: torch.device, mask_val: float = -1e4, # additive mask的遮挡值 ) -> torch.Tensor: """ - 对于 query 为有效 token (attention_mask==1) 的行： 仅允许观看 key 也是有效 token 的列 -> 完全互看 - 对于 query 为 padding 的行： 采用 causal 下三角 (j <= i) -> 避免整行 -inf 返回 shape = (bs, 1, L, L) 的 additive mask """ if attention_mask.dim() != 2: raise ValueError( "Expected 2-D attention_mask with shape (batch, seq_len)" ) bs, L = attention_mask.shape attn_mask_f = attention_mask.to(device=device, dtype=torch.float32) # 方便广播 # ---------- ① 有效 token 间的互看 ---------- # valid2valid[b,i,j] = 1 ⇔ query_i 与 key_j 均为 real valid2valid = attn_mask_f[:, :, None] * attn_mask_f[:, None, :] # (bs, L, L) # ---------- ② padding 行的因果下三角 ---------- # lower_tri[i,j] = 1 ⇔ j ≤ i lower_tri = torch.tril(torch.ones(L, L, device=device)) # query_is_pad: (bs, L, 1) 1=pad query_is_pad = (1.0 - attn_mask_f)[:, :, None] causal_part = query_is_pad * lower_tri # (bs, L, L) # ---------- ③ 合并两部分 ---------- visible = torch.clamp(valid2valid + causal_part, 0.0, 1.0) # (bs, L, L) # ---------- ④ 变 additive mask ---------- additive_mask = (1.0 - visible) * mask_val # 0->0, 1->mask_val additive_mask = additive_mask[:, None, :, :] # (bs,1,L,L) return additive_mask.to(dtype=dtype) def compute_chunk_lengths(slice_pos: torch.Tensor, pad_value: int = -100): """ Args: slice_pos: [B, L] 切分点，表示当前位置的 token 后面切一刀，-1 表示 padding Returns: length_gt: [B, max_chunk_num], 每个 chunk 的长度，不足部分填 pad_value """ B, L = slice_pos.shape device = slice_pos.device length_ground_truth = [] for b in range(B): pos = slice_pos[b] pos = pos[pos != -1] + 1 # 获取有效切分点并 +1（实际切在后面） cuts = torch.cat([ torch.tensor([0], device=device), # 起始点 pos, ]) lens = cuts[1:] - cuts[:-1] # 计算每段长度 # 补齐到 max_chunk_num（L） padded = torch.full((L,), pad_value, device=device, dtype=torch.long) padded[:lens.shape[0]] = lens length_ground_truth.append(padded) return torch.stack(length_ground_truth) # [B, L] class Olmo2ForCausalLMForSemiNAT(Olmo2ForCausalLM): def __init__(self, config, *args, **kwargs): super().__init__(config, *args, **kwargs) self.pos_encoder = AbsolutePositionalEncoding(config.hidden_size) self.config = config self.padding_idx = config.pad_token_id self.vocab_size = config.vocab_size self.chunk_size_limit = config.chunk_size_limit self.model = Olmo2ModelForSemiNAT(config) self.vocab_size = config.vocab_size self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False) # Initialize weights and apply final processing self.post_init() def forward( self, input_ids: torch.LongTensor = None, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, slice_pos: Optional[torch.Tensor] = None, slice_label: Optional[torch.Tensor] = None, past_key_values: Optional[List[torch.FloatTensor]] = None, inputs_embeds: Optional[torch.FloatTensor] = None, labels: Optional[torch.LongTensor] = None, use_cache: Optional[bool] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None, cache_position: Optional[torch.LongTensor] = None, logits_to_keep: Union[int, torch.Tensor] = 0, is_prefill: Optional[bool] = False, # padding: Optional[torch.Tensor] = None, **kwargs: Unpack[KwargsForCausalLM], ) -> Union[Tuple, CausalLMOutputWithPast]: output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions output_hidden_states = (output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states) return_dict = return_dict if return_dict is not None else self.config.use_return_dict # pdb.set_trace() # start = time.time() if labels is not None: outputs = self.model( input_ids=input_ids, # bs * length attention_mask=attention_mask, # bs * length position_ids=position_ids, slice_pos=slice_pos, past_key_values=past_key_values, inputs_embeds=inputs_embeds, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, cache_position=cache_position, padding=self.padding_idx, is_prefill=is_prefill, **kwargs, ) else: outputs = self.model( input_ids=input_ids, # bs * length attention_mask=attention_mask, # bs * length position_ids=position_ids, slice_pos=slice_pos, past_key_values=past_key_values, inputs_embeds=inputs_embeds, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, cache_position=cache_position, padding=self.padding_idx, inference=True, is_prefill=is_prefill, ) # pdb.set_trace() chunk_hidden_states = outputs.chunk_hidden_state bs, length, hidden_size = chunk_hidden_states.size() ############################# loss 计算，分两部分 ############################# loss = None loss1 = None loss2 = None ############################# 首先， 接上mlp，预测长度的loss，维度是10############################# if labels is not None: length_ground_truth = outputs.length_ground_truth length_logits = outputs.length_logits new_length_ground_truth = torch.where( length_ground_truth != -100, length_ground_truth - 1, length_ground_truth ) shift_length_logits = length_logits[:, :-1, :] shift_new_length_ground_truth = new_length_ground_truth[:, 1:] logits_flat = shift_length_logits.reshape(-1, self.chunk_size_limit) labels_flat = shift_new_length_ground_truth.reshape(-1) shift_slice_label = slice_label[:, 1:length_logits.size(1)] slice_label_flat = shift_slice_label.reshape(-1) mask = (slice_label_flat == -1) labels_flat[mask] = -100 length_loss_type = getattr(self.config, "length_loss_type", "ce") if length_loss_type == "mse": logits_softmax = torch.nn.functional.softmax(logits_flat, dim=-1) predicted_lengths = torch.sum( logits_softmax * torch.arange(self.chunk_size_limit).to( chunk_hidden_states.device).to(chunk_hidden_states.dtype), dim=1 ) loss1 = torch.mean((predicted_lengths[labels_flat != -100] - labels_flat[labels_flat != -100].float()) ** 2) elif length_loss_type == "ce": # cross entropy loss1 = F.cross_entropy( logits_flat[labels_flat != -100], labels_flat[labels_flat != -100] ) # pdb.set_trace() nar_hidden_state = outputs.nar_hidden_state ############################# 其次，用chunk的hidden recover所有token，跟gt计算loss ############################# nar_labels = torch.full( (nar_hidden_state.size(0), nar_hidden_state.size(1)), -100).to(nar_hidden_state.device) # bs * length nar_labels = self.update_nar_labels(nar_labels, labels, slice_pos, length_ground_truth, input_ids, self.chunk_size_limit) # Only compute necessary logits, and do not upcast them to float if we are not computing the loss slice_indices = slice(-logits_to_keep, None) if isinstance( logits_to_keep, int) else logits_to_keep logits = self.lm_head( nar_hidden_state[:, slice_indices, :]) # 1* seq_len * 50304 # logits = logits.float() # pdb.set_trace() # if labels is not None: loss2 = self.loss_function_seminat( logits, nar_labels, self.vocab_size, ) # grad1 = torch.autograd.grad(loss1, outputs.chunk_hidden_state, retain_graph=True)[0] # grad2 = torch.autograd.grad(loss2, outputs.chunk_hidden_state, retain_graph=True)[0] # cos_sim = cosine_similarity(grad1.flatten(), grad2.flatten(), dim=0) # pdb.set_trace() else: # for inference softmaxed = torch.softmax(outputs.length_logits[:, -1, :], dim=-1) length = torch.argmax(softmaxed, dim=-1).item() + 1 # nat_input_embeddings = torch.zeros( # 1, self.chunk_size_limit, hidden_size).to(input_ids.device).to( # outputs.chunk_hidden_state.dtype) nat_input_embeddings = torch.zeros( 1, length, hidden_size).to(input_ids.device).to( outputs.chunk_hidden_state.dtype) # nat_attention_mask = torch.zeros(1, self.chunk_size_limit).to( # input_ids.device).to(outputs.chunk_hidden_state.dtype) # pdb.set_trace() nat_input_embeddings[:, : length, :] = outputs.chunk_hidden_state[:, -1, :].expand( length, -1).to(input_ids.device).to( outputs.chunk_hidden_state.dtype) # pdb.set_trace() if self.config.mlp: nat_input_embeddings = self.linear_projection(nat_input_embeddings) # nat_attention_mask[:, :length] = torch.tensor([1] * length).to( # input_ids.device).to(outputs.chunk_hidden_state.dtype) # nar_chunk_position = torch.arange( # 0, self.chunk_size_limit).unsqueeze(0).to(input_ids.device).to( # outputs.chunk_hidden_state.dtype) # bs * max_chunk_num # nar_position_embeddings = self.pos_encoder(nat_attention_mask, # nar_chunk_position) # pdb.set_trace() nat_input_embeddings = self.pos_encoder(nat_input_embeddings) # 加上绝对位置编码 # pdb.set_trace() nar_hidden_states = self.model.decoder( nat_input_embeddings, # attention_mask=nat_attention_mask, attention_mask=None, # position_embeddings=nar_position_embeddings, position_embeddings=None, output_attentions=output_attentions, use_cache=False, cache_position=None, ) nar_hidden_states = self.model.norm(nar_hidden_states) # slice_indices = slice(-logits_to_keep, None) if isinstance( # logits_to_keep, int) else logits_to_keep logits = self.lm_head(nar_hidden_states[:, :, :]) # pdb.set_trace() return CausalLMOutputWithPast( loss=(loss1, loss2), logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) ############################# loss 计算，分两部分 ############################# # if not return_dict: # output = (logits, ) + outputs[1:] # if output_router_logits: # output = (aux_loss, ) + output # return (loss, ) + output if loss is not None else output # pdb.set_trace() return CausalLMOutputWithPast( loss=(loss1, loss2), logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states, attentions=outputs.attentions, ) def update_nar_labels(self, nar_labels, labels, slice_pos, length_ground_truth, input_ids, chunk_size_limit): bs, length = input_ids.size() chunk = 0 for b in range(bs): last_cut = slice_pos[b][0] #第一次切分位置 for i in range(1, length): if slice_pos[b, i] != -1: # pdb.set_trace() try: nar_labels[chunk, :length_ground_truth[b, i]] = labels[ b, last_cut + 1:slice_pos[b, i] + 1] except: pdb.set_trace() last_cut = slice_pos[b, i] chunk += 1 else: break # pdb.set_trace() return nar_labels def fixed_cross_entropy(self, source, target, num_items_in_batch: int = None, ignore_index: int = -100, **kwargs): reduction = "sum" if num_items_in_batch is not None else "mean" loss = F.cross_entropy(source, target, ignore_index=ignore_index, reduction=reduction) if torch.isnan(loss): # print(f"Step {global_step}: loss is NaN, entering pdb …") pdb.set_trace() # pdb.set_trace() if reduction == "sum": loss = loss / num_items_in_batch return loss def loss_function_seminat(self, logits, labels, vocab_size: int, num_items_in_batch: int = None, ignore_index: int = -100, **kwargs): # logits: (B, L, V) # labels: (B, L) logits = logits.float() labels = labels.to(logits.device) # Flatten the tokens (无 shift) logits = logits.view(-1, vocab_size) # (B*L, V) labels = labels.view(-1) # (B*L) # Ensure device alignment labels = labels.to(logits.device) # Compute loss loss = self.fixed_cross_entropy(logits, labels, num_items_in_batch, ignore_index, **kwargs) return loss def generate( self, inputs: Optional[torch.Tensor] = None, generation_config: Optional[GenerationConfig] = None, logits_processor: Optional[LogitsProcessorList] = None, stopping_criteria: Optional[StoppingCriteriaList] = None, prefix_allowed_tokens_fn: Optional[Callable[[int, torch.Tensor], List[int]]] = None, synced_gpus: Optional[bool] = None, assistant_model: Optional["PreTrainedModel"] = None, streamer: Optional["BaseStreamer"] = None, negative_prompt_ids: Optional[torch.Tensor] = None, negative_prompt_attention_mask: Optional[torch.Tensor] = None, prefilling_length: int = 0, **kwargs, ) -> Union[GenerateOutput, torch.LongTensor]: # 1. Handle `generation_config` and kwargs that might update it, and validate the `.generate()` call self._validate_model_class() #能进行generate的模型 tokenizer = kwargs.pop( "tokenizer", None) # Pull this out first, we only use it for stopping criteria assistant_tokenizer = kwargs.pop( "assistant_tokenizer", None) # only used for assisted generation # pdb.set_trace() generation_config, model_kwargs = self._prepare_generation_config( generation_config, **kwargs) # GenerationConfig { # "eos_token_id": 50279, # "max_length": 2048, # "pad_token_id": 1 # } # model_kwargs: {input_ids: , attention_mask:} # pdb.set_trace() self._validate_model_kwargs(model_kwargs.copy()) # 检查模型参数是否正确 self._validate_assistant(assistant_model, tokenizer, assistant_tokenizer) # 2. Set generation parameters if not already defined # 判断是否在多GPU环境下同步生成（如DeepSpeed ZeRO-3或FSDP） if synced_gpus is None: synced_gpus = ( is_deepspeed_zero3_enabled() or is_fsdp_managed_module(self)) and dist.get_world_size() > 1 # 初始化logits处理器和停止条件 logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList( ) # 定义对模型输出logits的修改规则（如禁止重复词、强制特定token等）。 stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList( ) # 定义生成停止条件（如达到最大长度、检测到终止符等）。 accepts_attention_mask = "attention_mask" in set( inspect.signature(self.forward).parameters.keys()) # True requires_attention_mask = "encoder_outputs" not in model_kwargs # True kwargs_has_attention_mask = model_kwargs.get("attention_mask", None) is not None # True # pdb.set_trace() # 3. Define model inputs inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs( inputs, generation_config.bos_token_id, model_kwargs) batch_size = inputs_tensor.shape[0] # inputs_tensor bs * input_length; model_input_name:"input_ids";model_kwargs: attention_mask device = inputs_tensor.device self._prepare_special_tokens(generation_config, kwargs_has_attention_mask, device=device) # decoder-only models must use left-padding for batched generation. # batch generation用的 if not self.config.is_encoder_decoder and not is_torchdynamo_compiling( ): # If `input_ids` was given, check if the last id in any sequence is `pad_token_id` # Note: If using, `inputs_embeds` this check does not work, because we want to be more hands-off. if (generation_config._pad_token_tensor is not None and batch_size > 1 and len(inputs_tensor.shape) == 2 and torch.sum(inputs_tensor[:, -1] == generation_config._pad_token_tensor) > 0): logger.warning( "A decoder-only architecture is being used, but right-padding was detected! For correct " "generation results, please set `padding_side='left'` when initializing the tokenizer." ) # pdb.set_trace() # 4. Define other model kwargs # decoder-only models with inputs_embeds forwarding must use caching (otherwise we can't detect whether we are # generating the first new token or not, and we only want to use the embeddings for the first new token) if not self.config.is_encoder_decoder and model_input_name == "inputs_embeds": generation_config.use_cache = True # 生成第一个新token时需要依赖缓存判断是否处于生成阶段，后续token生成依赖缓存加速。 # 生成attention mask if not kwargs_has_attention_mask and requires_attention_mask and accepts_attention_mask: model_kwargs[ "attention_mask"] = self._prepare_attention_mask_for_generation( inputs_tensor, generation_config, model_kwargs) # 输入了attention，检查一下对不对 elif kwargs_has_attention_mask: # TODO (joao): generalize this check with other types of inputs if model_input_name == "input_ids" and len( model_kwargs["attention_mask"].shape) > 2: raise ValueError( "`attention_mask` passed to `generate` must be 2D.") # encoder-decoder model设定 if self.config.is_encoder_decoder and "encoder_outputs" not in model_kwargs: # if model is encoder decoder encoder_outputs are created and added to `model_kwargs` model_kwargs = self._prepare_encoder_decoder_kwargs_for_generation( inputs_tensor, model_kwargs, model_input_name, generation_config) # pdb.set_trace() # 5. Prepare `input_ids` which will be used for auto-regressive generation # encoder-decoder model if self.config.is_encoder_decoder: input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation( batch_size=batch_size, model_input_name=model_input_name, model_kwargs=model_kwargs, decoder_start_token_id=generation_config. _decoder_start_token_tensor, device=inputs_tensor.device, ) else: input_ids = inputs_tensor if model_input_name == "input_ids" else model_kwargs.pop( "input_ids") # torch.Size([1, 25]) # torch.Size([1, 25]) # 修复不完整的token if generation_config.token_healing: input_ids = self.heal_tokens(input_ids, tokenizer) # 流式输出 if streamer is not None: streamer.put(input_ids.cpu()) # pdb.set_trace() # 6. Prepare `max_length` depending on other stopping criteria. input_ids_length = input_ids.shape[-1] has_default_max_length = kwargs.get( "max_length") is None and generation_config.max_length is not None has_default_min_length = kwargs.get( "min_length") is None and generation_config.min_length is not None # min_length是0 # 生成的一些config generation_config = self._prepare_generated_length( generation_config=generation_config, has_default_max_length=has_default_max_length, has_default_min_length=has_default_min_length, model_input_name=model_input_name, # "input_ids" inputs_tensor=inputs_tensor, input_ids_length=input_ids_length, #输入长度 ) # If the model supports `logits_to_keep` in forward(), set it to 1 to avoid computing the whole # logit matrix. This can save a lot of memory during the first forward pass. Note that assisted decoding # dynamically overrides this value as it can need more than the last token logits if self._supports_logits_to_keep( ) and "logits_to_keep" not in model_kwargs: model_kwargs["logits_to_keep"] = 1 # 模型在计算时仅保留最后一个 token 的 logits，而非整个词汇表的 logits，从而大幅降低内存占用。若使用束搜索宽度为 5，辅助解码会覆盖 logits_to_keep=5，保留多个候选 token 的 logits 以支持多路径探索。 # 检查生成长度 self._validate_generated_length(generation_config, input_ids_length, has_default_max_length) # pdb.set_trace() # 7. Prepare the cache. # - `model_kwargs` may be updated in place with a cache as defined by the parameters in `generation_config`. # - different models have a different cache name expected by the model (default = "past_key_values") # - `max_length`, prepared above, is used to determine the maximum cache length max_cache_length = generation_config.max_length - 1 #存最长length-1个token cache # 如果输入是emb if (inputs_tensor.shape[1] != input_ids_length and model_input_name == "inputs_embeds" and not self.config.is_encoder_decoder): max_cache_length += inputs_tensor.shape[1] self._prepare_cache_for_generation(generation_config, model_kwargs, assistant_model, batch_size, max_cache_length, device) # 8. determine generation mode generation_mode = generation_config.get_generation_mode( assistant_model) # 辅助解码 if streamer is not None and (generation_config.num_beams > 1): raise ValueError( "`streamer` cannot be used with beam search (yet!). Make sure that `num_beams` is set to 1." ) # device检查 if not is_torchdynamo_compiling( ) and self.device.type != input_ids.device.type: warnings.warn( "You are calling .generate() with the `input_ids` being on a device type different" f" than your model's device. `input_ids` is on {input_ids.device.type}, whereas the model" f" is on {self.device.type}. You may experience unexpected behaviors or slower generation." " Please make sure that you have put `input_ids` to the" f" correct device by calling for example input_ids = input_ids.to('{self.device.type}') before" " running `.generate()`.", UserWarning, ) # pdb.set_trace() # 9. prepare logits processors and stopping criteria prepared_logits_processor = self._get_logits_processor( generation_config=generation_config, input_ids_seq_length=input_ids_length, encoder_input_ids=inputs_tensor, prefix_allowed_tokens_fn=prefix_allowed_tokens_fn, logits_processor=logits_processor, device=inputs_tensor.device, model_kwargs=model_kwargs, negative_prompt_ids=negative_prompt_ids, negative_prompt_attention_mask=negative_prompt_attention_mask, ) prepared_stopping_criteria = self._get_stopping_criteria_for_seminat( generation_config=generation_config, stopping_criteria=stopping_criteria, tokenizer=tokenizer, **kwargs) # Set model_kwargs `use_cache` so we can use it later in forward runs model_kwargs["use_cache"] = generation_config.use_cache input_ids, model_kwargs = self._expand_inputs_for_generation( input_ids=input_ids, expand_size=generation_config.num_return_sequences, # 1 is_encoder_decoder=self.config.is_encoder_decoder, # false **model_kwargs, ) # pdb.set_trace() result = self._sampleforseminat( input_ids, logits_processor=prepared_logits_processor, # 用于在每一步生成 token 前，修改模型输出的 logits 分布，常用于控制生成行为、避免重复、强制某些 token 出现或屏蔽某些 token。 stopping_criteria=prepared_stopping_criteria, generation_config=generation_config, synced_gpus=synced_gpus, #多gpu streamer=streamer, prefilling_length=prefilling_length, **model_kwargs, ) # Convert to legacy cache format if requested if (generation_config.return_legacy_cache is True and not is_torchdynamo_compiling() and hasattr(result, "past_key_values") and getattr( result.past_key_values, "to_legacy_cache") is not None): result.past_key_values = result.past_key_values.to_legacy_cache() return result def _get_stopping_criteria_for_seminat( self, generation_config: GenerationConfig, stopping_criteria: Optional[StoppingCriteriaList], tokenizer: Optional["PreTrainedTokenizerBase"] = None, **kwargs, ) -> StoppingCriteriaList: criteria = StoppingCriteriaList() if generation_config.max_length is not None: max_position_embeddings = getattr(self.config, "max_position_embeddings", None) criteria.append( MaxLengthCriteria( max_length=generation_config.max_length, max_position_embeddings=max_position_embeddings, ) ) if generation_config.max_time is not None: criteria.append(MaxTimeCriteria(max_time=generation_config.max_time)) if generation_config.stop_strings is not None: if tokenizer is None: raise ValueError( "There are one or more stop strings, either in the arguments to `generate` or in the " "model's generation config, but we could not locate a tokenizer. When generating with " "stop strings, you must pass the model's tokenizer to the `tokenizer` argument of `generate`." ) criteria.append(StopStringCriteria(stop_strings=generation_config.stop_strings, tokenizer=tokenizer)) if generation_config._eos_token_tensor is not None: criteria.append(EosTokenCriteriaForSemiNAT(eos_token_id=generation_config._eos_token_tensor)) if ( generation_config.is_assistant and generation_config.assistant_confidence_threshold is not None and generation_config.assistant_confidence_threshold > 0 ): criteria.append( ConfidenceCriteria(assistant_confidence_threshold=generation_config.assistant_confidence_threshold) ) criteria = self._merge_criteria_processor_list(criteria, stopping_criteria) return criteria def _sampleforseminat( self, input_ids: torch.LongTensor, logits_processor: LogitsProcessorList, stopping_criteria: StoppingCriteriaList, generation_config: GenerationConfig, synced_gpus: bool, streamer: Optional["BaseStreamer"], prefilling_length: int, **model_kwargs, ) -> Union[GenerateNonBeamOutput, torch.LongTensor]: # init values pad_token_id = generation_config._pad_token_tensor # 获取填充token的ID output_attentions = generation_config.output_attentions # 是否输出注意力权重 output_hidden_states = generation_config.output_hidden_states # 是否输出隐藏状态 output_scores = generation_config.output_scores # 是否输出分数 output_logits = generation_config.output_logits # 是否输出原始logits return_dict_in_generate = generation_config.return_dict_in_generate # 是否返回结构化字典 max_length = generation_config.max_length # 最大生成长度 has_eos_stopping_criteria = any( hasattr(criteria, "eos_token_id") for criteria in stopping_criteria) # 检查停止条件是否包含EOS token do_sample = generation_config.do_sample # 是否使用采样方法 # 初始化结果收集容器 # init attention / hidden states / scores tuples scores = () if (return_dict_in_generate and output_scores) else None raw_logits = () if (return_dict_in_generate and output_logits) else None decoder_attentions = () if (return_dict_in_generate and output_attentions) else None cross_attentions = () if (return_dict_in_generate and output_attentions) else None decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None # # 编码器-解码器模型特殊处理 不用管 # if model is an encoder-decoder, retrieve encoder attention weights and hidden states if return_dict_in_generate and self.config.is_encoder_decoder: encoder_attentions = model_kwargs["encoder_outputs"].get( "attentions") if output_attentions else None encoder_hidden_states = ( model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None) # pdb.set_trace() # 初始化序列跟踪 # keep track of which sequences are already finished batch_size, cur_len = input_ids.shape this_peer_finished = False unfinished_sequences = torch.ones( batch_size, dtype=torch.long, device=input_ids.device) # 初始化未完成序列标记 torch.Size([1]) model_kwargs = self._get_initial_cache_position( input_ids, model_kwargs) # 初始化缓存位置 model_forward = self.__call__ # 获取前向传播函数 ############ 换成新的forward # model_forward = self.forward # pdb.set_trace() if isinstance(model_kwargs.get("past_key_values"), Cache): is_compileable = model_kwargs[ "past_key_values"].is_compileable and self._supports_static_cache #编译优化 is_compileable = is_compileable and not self.generation_config.disable_compile if is_compileable and ( self.device.type == "cuda" or generation_config.compile_config._compile_all_devices): os.environ["TOKENIZERS_PARALLELISM"] = "0" model_forward = self.get_compiled_call( generation_config.compile_config) ############ prefilling ############ start = prefilling_length-1 chunk_length = prefilling_length s_pos = [start] while True: start += chunk_length if start >= input_ids.shape[1] - 1: s_pos.append(input_ids.shape[1] - 1) break else: s_pos.append(start) # pdb.set_trace() slice_pos = torch.tensor(s_pos).unsqueeze(0).to( input_ids.device) # slice_pos = torch.tensor(s_pos + [-1] * # (cur_len - len(s_pos))).unsqueeze(0).to( # input_ids.device) model_kwargs['slice_pos'] = slice_pos count = (slice_pos != -1).sum().item() # new_cache_position = torch.arange(0, count).to(input_ids.device) # model_kwargs[ # 'cache_position'] = new_cache_position # chunk级别 # pdb.set_trace() ############ prefilling ############ is_prefill = True while self._has_unfinished_sequences( this_peer_finished, synced_gpus, device=input_ids.device, cur_len=cur_len, max_length=max_length): # 循环知道序列生成完 # prepare model inputs # pdb.set_trace() # model_kwargs.keys(): dict_keys(['attention_mask', 'logits_to_keep', 'past_key_values', 'use_cache', 'cache_position', 'nar_kv_cache', 'slice_pos']) model_inputs = self.prepare_inputs_for_generation( #加入position_id和input_id input_ids, **model_kwargs ) #dict_keys(['cache_position', 'past_key_values', 'input_ids', 'inputs_embeds', 'position_ids', 'attention_mask', 'logits_to_keep', 'use_cache']) # pdb.set_trace() # position_ids = torch.arange( # input_ids.shape[1], device=input_ids.device).unsqueeze(0).to(input_ids.device) # model_inputs.update({"position_ids": position_ids}) model_inputs.update({"input_ids": input_ids}) # prepare variable output controls (note: some models won't accept all output controls) model_inputs.update({"output_attentions": output_attentions} if output_attentions else {}) model_inputs.update({"output_hidden_states": output_hidden_states} if output_hidden_states else {}) if is_prefill: # pdb.set_trace() # outputs = self(**model_inputs, return_dict=True) # dict_keys(['cache_position', 'past_key_values', 'input_ids', 'inputs_embeds', 'position_ids', 'attention_mask', 'logits_to_keep', 'use_cache']) outputs = self.forward(**model_inputs, return_dict=True, is_prefill=True) #这里position_ids是错的 is_prefill = False else: # pdb.set_trace() outputs = model_forward(**model_inputs, return_dict=True, is_prefill=False) # pdb.set_trace() ################ seminat ########################### # model_kwargs['slice_pos'] = outputs.slice_pos ################ seminat ########################### # synced_gpus: don't waste resources running the code we don't need; kwargs must be updated before skipping model_kwargs = self._update_model_kwargs_for_generation_for_seminat( outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder, num_new_tokens=outputs.logits.size(1)) if synced_gpus and this_peer_finished: continue # Clone is needed to avoid keeping a hanging ref to outputs.logits which may be very large for first iteration # (the clone itself is always small) # next_token_logits = outputs.logits[:, -1, :].clone().float() next_token_logits = outputs.logits[:, :, :].clone().float( ) # 新生成了k个token next_token_logits = next_token_logits.to(input_ids.device) # pre-process distribution next_token_scores = logits_processor(input_ids, next_token_logits) # token selection if do_sample: probs = nn.functional.softmax(next_token_scores, dim=-1) # TODO (joao): this OP throws "skipping cudagraphs due to ['incompatible ops']", find solution next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1) else: next_tokens = torch.argmax( next_token_scores, dim=-1) # tensor([9281], device='cuda:0') token id # pdb.set_trace() # 更新slice_pos count = (model_kwargs['slice_pos'] != -1).sum().item() new_slice_pos = model_kwargs['slice_pos'][:, count - 1] + outputs.logits.size(1) model_kwargs['slice_pos'] = torch.cat([model_kwargs['slice_pos'], new_slice_pos.unsqueeze(1)], dim=-1) # pdb.set_trace() # finished sentences should have their next token be a padding token if has_eos_stopping_criteria: next_tokens = next_tokens * unfinished_sequences + pad_token_id * ( 1 - unfinished_sequences ) # 序列生成完的时候，unfinished_sequences为0，正好后面全填上padding # pdb.set_trace() # update generated ids, model inputs, and length for next step # input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1) input_ids = torch.cat([input_ids, next_tokens], dim=-1) if streamer is not None: streamer.put(next_tokens.cpu()) # 更新完成状态 unfinished_sequences = unfinished_sequences & ~stopping_criteria( input_ids, scores, last_k=next_tokens.size(1)) this_peer_finished = unfinished_sequences.max() == 0 cur_len += outputs.logits.size(1) # 长度 + n # pdb.set_trace() # This is needed to properly delete outputs.logits which may be very large for first iteration # Otherwise a reference to outputs is kept which keeps the logits alive in the next iteration del outputs if streamer is not None: streamer.end() if return_dict_in_generate: if self.config.is_encoder_decoder: return GenerateEncoderDecoderOutput( sequences=input_ids, scores=scores, logits=raw_logits, encoder_attentions=encoder_attentions, encoder_hidden_states=encoder_hidden_states, decoder_attentions=decoder_attentions, cross_attentions=cross_attentions, decoder_hidden_states=decoder_hidden_states, past_key_values=model_kwargs.get("past_key_values"), ) else: return GenerateDecoderOnlyOutput( sequences=input_ids, scores=scores, logits=raw_logits, attentions=decoder_attentions, hidden_states=decoder_hidden_states, past_key_values=model_kwargs.get("past_key_values"), ) else: return input_ids def _update_model_kwargs_for_generation_for_seminat( self, outputs: ModelOutput, model_kwargs: Dict[str, Any], is_encoder_decoder: bool = False, num_new_tokens: int = 1, ) -> Dict[str, Any]: ALL_CACHE_NAMES = [ "past_key_values", # default "cache_params", # mamba-based models "state", # rwkv "mems", # xlnet "past_buckets_states", # reformer ] # update past_key_values keeping its naming used in model code for possible_cache_name in ALL_CACHE_NAMES: if possible_cache_name in outputs: # TODO (joao): remove output/input mismatch when these old models (xlnet, reformer) are deprecated if possible_cache_name in ("past_buckets_states", "mems"): cache_name = "past_key_values" else: cache_name = possible_cache_name model_kwargs[cache_name] = getattr(outputs, possible_cache_name) break # pdb.set_trace() # update token_type_ids with last value # false if "token_type_ids" in model_kwargs: token_type_ids = model_kwargs["token_type_ids"] model_kwargs["token_type_ids"] = torch.cat( [token_type_ids, token_type_ids[:, -1].unsqueeze(-1)], dim=-1) if not is_encoder_decoder: # update attention mask # 重点看这个 # pdb.set_trace() if "attention_mask" in model_kwargs: attention_mask = model_kwargs["attention_mask"] model_kwargs["attention_mask"] = torch.cat( [ attention_mask, attention_mask.new_ones( (attention_mask.shape[0], num_new_tokens )) # 1 -> num_new_tokens 一次加多个token的attention ], dim=-1) else: # update decoder attention mask if "decoder_attention_mask" in model_kwargs: decoder_attention_mask = model_kwargs["decoder_attention_mask"] model_kwargs["decoder_attention_mask"] = torch.cat( [ decoder_attention_mask, decoder_attention_mask.new_ones( (decoder_attention_mask.shape[0], 1)) ], dim=-1, ) # pdb.set_trace() if model_kwargs.get("use_cache", True): model_kwargs["cache_position"] = torch.arange(model_kwargs["cache_position"][-1:].item() + 1, model_kwargs["cache_position"][-1:].item() + num_new_tokens + 1, dtype=model_kwargs["cache_position"].dtype).to(model_kwargs["cache_position"].device) # model_kwargs["cache_position"] = torch.tensor([ # model_kwargs["cache_position"][-1:].item() + 1 # ]).to(model_kwargs["cache_position"].device) else: past_positions = model_kwargs.pop("cache_position") new_positions = torch.arange( past_positions[-1] + 1, past_positions[-1] + num_new_tokens + 1, dtype=past_positions.dtype).to(past_positions.device) model_kwargs["cache_position"] = torch.cat( (past_positions, new_positions)) return model_kwargs class AbsolutePositionalEncoding(nn.Module): def __init__(self, hidden_size: int, max_len: int = 2048): """ 初始化绝对位置编码 参数: hidden_size (int): 隐藏层维度 max_len (int): 最大序列长度 """ super().__init__() # 创建位置编码矩阵 pe = torch.zeros(max_len, hidden_size) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, hidden_size, 2).float() * (-math.log(10000.0) / hidden_size)) # 使用sin和cos函数计算位置编码 pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0) # [1, max_len, hidden_size] # 注册为buffer（不参与训练） self.register_buffer('pe', pe) def forward(self, x: torch.Tensor) -> torch.Tensor: """ 添加位置编码到输入张量 参数: x (torch.Tensor): 输入张量，形状为 (batch_size, seq_len, hidden_size) 返回: torch.Tensor: 添加位置编码后的张量，形状与输入相同 """ seq_len = x.size(1) pos = x + self.pe[:, :seq_len] # pdb.set_trace() return pos