Upload modelforseminat_v5.py with huggingface_hub

modelforseminat_v5.py

@@ -0,0 +1,2156 @@
+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 time
+import os
+import sys
+import json
+import pdb
+import torch.distributed as dist
+from tqdm import tqdm
+from torch.utils.data.distributed import DistributedSampler
+import transformers
+import pickle
+from dataset import *
+# from peft import (get_peft_model, PeftModel)
+import random
+from config import *
+from datasets import Dataset, DatasetDict, load_dataset
+import wandb
+import argparse
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import functools
+from torch.optim.lr_scheduler import StepLR
+import torch.nn.functional as F
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
+    checkpoint_wrapper, CheckpointImpl)
+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 Olmo2AttentionForSemiNAT(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config: Olmo2Config, 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()
+        
+        self.config._attn_implementation = "sdpa"
+        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]
+
+
+        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,
+            **kwargs,
+        )
+
+        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: Olmo2Config,
+        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,
+        )
+        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: Olmo2Config, num_layer: int = 1):
+        super().__init__()
+        self.num_layer = num_layer
+        self.encoder_layers = nn.ModuleList([
+            Olmo2DecoderLayerForSemiNAT(config, layer_idx)
+            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: Olmo2Config, 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, 1)
+        self.encoder = NATEncoderForSemiNAT(config, 1)
+
+
+        # 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.linear_projection = TwoLayerMLP(config.hidden_size)
+
+
+    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,
+        **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)
+
+        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()
+
+        ################################ 并行处理 #################################
+        M_avg, attn_mask, length_ground_truth, chunk_attention_mask, slice_num = self.build_slice_matrix(slice_pos) # torch.Size([1, 111, 512])
+        
+        # pdb.set_trace()
+        encoded_input = self.encoder(inputs_embeds,position_embeddings=position_embeddings,attention_mask=attn_mask) # torch.Size([1, 512, 2048])
+        # 这里attention_mask没有用，因为encoder没有attention层
+
+        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]
+        # pdb.set_trace()
+        ################################ 并行处理 #################################
+
+
+        ################################ 串行处理 #################################
+        # 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长度裁剪，加速计算
+        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]
+        
+        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:
+            
+            # inference 把填充去掉
+            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
+        
+        
+        # pdb.set_trace()
+
+
+        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,
+                    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=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
+
+        # pdb.set_trace()
+
+        # 算长度预测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()
+
+        next_cache = next_decoder_cache if use_cache else None  # DynamicCache()
+        # if return_legacy_cache:
+        #     next_cache = next_cache.to_legacy_cache()
+
+
+        # 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)
+
+
+
+
+
+
+
+
+
+            # 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()
+            # nar_chunk_position = torch.arange(
+            #     0, self.chunk_size_limit).unsqueeze(0).repeat(
+            #         accumu_num,
+            #         1).to(hidden_states.device)  # bs * max_chunk_num
+
+            # nar_position_embeddings = self.rotary_emb(nat_attention_mask,
+            #                                           nar_chunk_position)
+
+
+            # pdb.set_trace()
+
+            nat_input_embeddings = self.pos_encoder(nat_input_embeddings) # 加上绝对位置编码
+
+
+            self.decoder = self.decoder.to(dtype=nat_input_embeddings.dtype)
+
+
+            # 处理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()
+            nar_hidden_states = self.decoder(
+                nat_input_embeddings,
+                attention_mask=mask_nat_attention_mask,
+                # attention_mask=None,
+                # position_embeddings=nar_position_embeddings,
+                position_embeddings=None, #使用绝对位置，不传相对位置
+                output_attentions=output_attentions,
+                use_cache=use_cache,
+                cache_position=None,
+            )
+
+            nar_hidden_states = self.norm(
+                nar_hidden_states)  # bs * max_chunk_num * hidden_size
+
+
+        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, slice_pos: 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  # 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.ones((bs, 1, seq_len, seq_len), dtype=torch.bool, device=slice_pos.device)
+
+        # 遍历填充 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_] = False
+        # 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,
+        # 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,
+                **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,
+            )
+
+        # end1 = time.time()
+        # print(f"end1 time: {end1 - start:.4f} 秒")
+
+
+
+        # 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,  # 条件：不等于 -100
+                length_ground_truth - 1,  # 如果条件为真，执行 labels - 1
+                length_ground_truth  # 否则保持原值
+            )
+
+            # pdb.set_trace()
+
+            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)  # 形状变为 [bs * length, chunk_size_limit]
+            labels_flat = shift_new_length_ground_truth.reshape(
+                -1)  # [bs * length]
+
+            # softmax logits to get probability
+            logits_flat = torch.nn.functional.softmax(logits_flat, dim=-1)
+
+            # 修改 loss 为 MSE: 首先根据 logits 加权得到预测长度（注意不是 argmax），之后与 label 计算 MSE
+
+            # pdb.set_trace()
+            # 计算预测长度
+            predicted_lengths = torch.sum(
+                logits_flat * torch.arange(self.chunk_size_limit).to(
+                    chunk_hidden_states.device).to(chunk_hidden_states.dtype),
+                dim=1)
+            # 计算预测长度与真实长度之间的均方误差
+
+            
+
+
+            shift_slice_label = slice_label[:, 1:length_logits.size(1)] #用最大chunk数阶段
+            slice_label_flat = shift_slice_label.reshape(-1)
+
+            # 对应 labels_flat 的 global indices
+            indices = torch.arange(0, labels_flat.size(0), device=labels_flat.device)
+            mask = (slice_label_flat == -1)
+
+            # pdb.set_trace()
+            # labels_not_ignored = (labels_flat[indices] != -100)
+            # final_mask = mask & labels_not_ignored
+            labels_flat[indices[mask]] = -100
+
+            
+
+
+            loss1 = torch.mean((predicted_lengths[labels_flat != -100] -
+                                labels_flat[labels_flat != -100].float())**2)
+
+            # 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
+            # pdb.set_trace()
+
+            # 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)
+
+            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[:, :, :])
+            
+            # end2 = time.time()
+            # print(f"end2 time: {end2 - end1:.4f} 秒")
+
+            # 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()
+        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
+
+        generation_config, model_kwargs = self._prepare_generation_config(
+            generation_config, **kwargs)
+
+        # GenerationConfig {
+        # "eos_token_id": 50279,
+        # "max_length": 2048,
+        # "pad_token_id": 1
+        # }
+
+        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  # False
+
+        # 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";
+
+        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)
+
+        # 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)
+
+        # 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,
+            stopping_criteria=prepared_stopping_criteria,
+            generation_config=generation_config,
+            synced_gpus=synced_gpus,
+            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
+
+        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 + [-1] *
+                                 (max_length - 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  # 更新一下cache position
+
+        # 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 = False
+            else:
+                # pdb.set_trace()
+                outputs = model_forward(**model_inputs, return_dict=True)
+
+            # 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
+
+            # pdb.set_trace()
+            # 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()
+            model_kwargs['slice_pos'][:, count] = model_kwargs[
+                'slice_pos'][:, count - 1] + outputs.logits.size(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)  # 长度 +1
+
+            # 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"] = model_kwargs["cache_position"][-1:] + num_new_tokens
+            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