Upload modelforseminat_v3.py with huggingface_hub

modelforseminat_v3.py

@@ -0,0 +1,1543 @@
+from transformers import OlmoModel, OlmoForCausalLM, AutoTokenizer
+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
+
+# Olmo
+from transformers.models.olmo.configuration_olmo import OlmoConfig
+from transformers.models.olmo.modeling_olmo import OlmoMLP, OlmoAttention, apply_rotary_pos_emb, repeat_kv, OlmoRotaryEmbedding, OlmoMLP
+from transformers.models.olmo.configuration_olmo import OlmoConfig
+
+# Olmoe
+from transformers.models.olmoe.modeling_olmoe import OlmoeRMSNorm
+# from transformers.models.olmoe.configuration_olmoe import OlmoeConfig
+# from transformers.models.olmoe.modeling_olmoe import OlmoeMLP, OlmoeAttention, OlmoeFlashAttention2, OlmoeSdpaAttention, OlmoeRMSNorm, OlmoeSparseMoeBlock, apply_rotary_pos_emb, repeat_kv, OlmoeRotaryEmbedding
+# from transformers.models.olmoe.configuration_olmoe import OlmoeConfig
+
+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)
+
+############ specially for generate() #################
+
+
+@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 OlmoAttentionForSemiNAT(nn.Module):
+
+    def __init__(
+        self,
+        config: OlmoConfig,
+        layer_idx: Optional[int] = None,
+    ):
+        super().__init__()
+        self.config = config
+        self.layer_idx = layer_idx
+        if layer_idx is None:
+            print(
+                f"Instantiating {self.__class__.__name__} without passing a `layer_idx` will lead to errors during the forward call if caching is used."
+            )
+        self.attention_dropout = config.attention_dropout
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.hidden_size // self.num_heads
+
+        # GQA
+        # n_k_v_h is the number of key/value heads
+        # n_k_v_g is the number of query heads per k/v head
+        self.num_key_value_heads = config.num_key_value_heads
+        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
+
+        self.max_position_embeddings = config.max_position_embeddings
+        self.rope_theta = config.rope_theta
+
+        if (self.head_dim * self.num_heads) != self.hidden_size:
+            raise ValueError(
+                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
+                f" and `num_heads`: {self.num_heads}).")
+
+        self.q_proj = nn.Linear(self.hidden_size,
+                                self.num_heads * self.head_dim,
+                                bias=config.attention_bias)
+        self.k_proj = nn.Linear(self.hidden_size,
+                                self.num_key_value_heads * self.head_dim,
+                                bias=config.attention_bias)
+        self.v_proj = nn.Linear(self.hidden_size,
+                                self.num_key_value_heads * self.head_dim,
+                                bias=config.attention_bias)
+        self.o_proj = nn.Linear(self.hidden_size,
+                                self.hidden_size,
+                                bias=config.attention_bias)
+        # pdb.set_trace()
+        self.q_norm = OlmoeRMSNorm(self.hidden_size, eps=config.rms_norm_eps)
+        self.k_norm = OlmoeRMSNorm(
+            (self.hidden_size // self.num_heads) * self.num_key_value_heads,
+            eps=config.rms_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        past_key_value: Optional[Cache] = None,
+        output_attentions: bool = False,
+        cache_position: Optional[torch.LongTensor] = None,
+        position_embeddings: Optional[Tuple[torch.Tensor,
+                                            torch.Tensor]] = None,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor],
+               Optional[Tuple[torch.Tensor]]]:
+        bsz, q_len, _ = hidden_states.size()  # bs * length * hidden_size
+        query_states = self.q_norm(
+            self.q_proj(hidden_states))  # bs * length * hidden_size
+        key_states = self.k_norm(self.k_proj(
+            hidden_states))  # bs * length * (num_key_value_heads * head_dim)
+        value_states = self.v_proj(
+            hidden_states)  # bs * length * (num_key_value_heads * head_dim)
+
+        if self.config.clip_qkv is not None:
+            query_states.clamp_(min=-self.config.clip_qkv,
+                                max=self.config.clip_qkv)
+            key_states.clamp_(min=-self.config.clip_qkv,
+                              max=self.config.clip_qkv)
+            value_states.clamp_(min=-self.config.clip_qkv,
+                                max=self.config.clip_qkv)
+
+        # 拆成各个头
+        query_states = query_states.view(
+            bsz, q_len, self.num_heads,
+            self.head_dim).transpose(1,
+                                     2)  # bs * num_heads * length * head_dim
+        key_states = key_states.view(
+            bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(
+                1, 2)  # bs * num_key_value_heads * length * head_dim
+        value_states = value_states.view(
+            bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(
+                1, 2)  # bs * num_key_value_heads * length * head_dim
+
+        cos, sin = position_embeddings  # bs * length * head_dim
+        query_states, key_states = apply_rotary_pos_emb(
+            query_states, key_states, cos,
+            sin)  # bs * num_heads (or num_key_value_heads) * length * head_dim
+
+        # TODO: check 一下 past_key_value.update 的具体实现（specific to RoPE）
+        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)
+
+        key_states = repeat_kv(
+            key_states,
+            self.num_key_value_groups)  # bs * num_heads * length * head_dim
+        value_states = repeat_kv(
+            value_states,
+            self.num_key_value_groups)  # bs * num_heads * length * head_dim
+        attn_weights = torch.matmul(
+            query_states, key_states.transpose(2, 3)) / math.sqrt(
+                self.head_dim)  # bs * num_heads * length * length
+
+        # try:
+        # TODO: check attention_mask 传进来的内容
+        if attention_mask is not None:  # no matter the length, we just slice it
+            causal_mask = attention_mask[:, :, :, :key_states.shape[
+                -2]]  # bs * 1 * (q_)length * (k_)length
+            attn_weights = attn_weights + causal_mask
+        # except:
+        #     pdb.set_trace()
+
+        attn_weights = nn.functional.softmax(
+            attn_weights, dim=-1, dtype=torch.float32).to(
+                query_states.dtype)  # bs * num_heads * length * length
+        attn_weights = nn.functional.dropout(
+            attn_weights, p=self.attention_dropout,
+            training=self.training)  # bs * num_heads * length * length
+        attn_output = torch.matmul(
+            attn_weights, value_states)  # bs * num_heads * length * head_dim
+
+        if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
+            raise ValueError(
+                f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
+                f" {attn_output.size()}")
+
+        attn_output = attn_output.transpose(
+            1, 2).contiguous()  # bs * length * num_heads * head_dim
+        attn_output = attn_output.reshape(
+            bsz, q_len, self.hidden_size)  # bs * length * hidden_size
+        attn_output = self.o_proj(attn_output)  # bs * length * hidden_size
+
+        if not output_attentions:
+            attn_weights = None
+        return attn_output, attn_weights, past_key_value
+
+
+class OlmoDecoderLayerForSemiNAT(nn.Module):
+
+    def __init__(
+        self,
+        config: OlmoConfig,
+        layer_idx: int,
+    ):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.self_attn = OlmoAttentionForSemiNAT(config=config,
+                                                 layer_idx=layer_idx)
+        self.mlp = OlmoMLP(config)
+        self.input_layernorm = OlmoeRMSNorm(config.hidden_size,
+                                            eps=config.rms_norm_eps)
+        self.post_attention_layernorm = OlmoeRMSNorm(config.hidden_size,
+                                                     eps=config.rms_norm_eps)
+
+    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]]]:
+        """
+        attention_mask: (bs, seq_len) if flash attention or (bs, 1, q_seq_len, k_seq_len) if default
+
+        past_key_value: Tuple(torch.FloatTensor)
+
+        position_embeddings `Tuple[torch.FloatTensor, torch.FloatTensor]`, cos and sin of shape (batch_size, seq_len, head_dim)
+        """
+
+        residual = hidden_states  # bs * length * hidden_size
+        # pdb.set_trace()
+        hidden_states = self.input_layernorm(hidden_states)
+
+        # Self Attention
+        hidden_states, self_attn_weights, present_key_value = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            past_key_value=past_key_value,
+            output_attentions=output_attentions,
+            cache_position=cache_position,
+            position_embeddings=position_embeddings,
+        )
+        hidden_states = residual + hidden_states  # bs * length * hidden_size
+
+        # MLP
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states, )
+        if output_attentions:
+            outputs += (self_attn_weights, )
+        if use_cache:
+            outputs += (present_key_value, )
+        return outputs
+
+
+class NATEncoderForSemiNAT(nn.Module):
+
+    def __init__(self, config: OlmoConfig, num_layer: int = 1):
+        super().__init__()
+        self.num_layer = num_layer
+        self.encoder_layers = nn.ModuleList([
+            OlmoDecoderLayerForSemiNAT(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)
+            hidden_states = outputs[0]
+        # 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: OlmoConfig, num_layer: int = 1):
+        super().__init__()
+        self.num_layer = num_layer
+        self.decoder_layers = nn.ModuleList([
+            OlmoDecoderLayerForSemiNAT(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]]]:
+
+        for layer in self.decoder_layers:
+            # pdb.set_trace()
+            outputs = layer(hidden_states=hidden_states,
+                            output_attentions=output_attentions,
+                            position_embeddings=position_embeddings)
+            hidden_states = outputs[0]
+        return hidden_states
+
+
+class OlmoModelForSemiNAT(OlmoModel):
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.layers = nn.ModuleList([
+            OlmoDecoderLayerForSemiNAT(config, layer_idx)
+            for layer_idx in range(config.num_hidden_layers)
+        ])
+
+        self.decoder = NATDecoderForSemiNAT(config, 1)
+        self.encoder = NATEncoderForSemiNAT(config, 1)
+        self.chunk_size_limit = config.chunk_size_limit
+
+        # self.decoder = NATDecoderForSemiNAT(config, 1)
+        self.length_predictor = nn.Linear(config.hidden_size,
+                                          self.chunk_size_limit)
+
+    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,
+        cache_position: Optional[torch.LongTensor] = None,
+        inference: Optional[bool] = None,
+    ) -> 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
+
+        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:
+            print(
+                "`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)
+
+        # kept for BC (non `Cache` `past_key_values` inputs)
+        return_legacy_cache = False
+
+        if use_cache and not isinstance(past_key_values, Cache):
+            return_legacy_cache = True
+            if past_key_values is None:
+                past_key_values = DynamicCache()
+            else:
+                past_key_values = DynamicCache.from_legacy_cache(
+                    past_key_values)
+                print(
+                    "Passing `past_key_values` as a tuple of tuples has been deprecated."
+                )
+        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  # 0-255, length
+            )
+
+        if position_ids is None:
+            position_ids = cache_position.unsqueeze(0)  #0-255, length
+
+        if inference:
+            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
+
+        # pdb.set_trace()
+
+        # initialize chunk inputs as embedding of [pad]
+        pad_token_id = 1
+        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
+        # pad_chunk_emb = self.encoder(
+        #     pad_embedding.unsqueeze(0),
+        #     attention_mask=None,
+        #     position_embeddings=position_embeddings[:, :1, :],
+        # )  # 1 * 1 * hidden_size
+        chunk_inputs_embeds = pad_embedding.expand(
+            batch_size, seq_len, hidden_size).clone().to(
+                inputs_embeds.device)  # bs * length * hidden_size 预填充
+
+        # 遍历 batch 和序列
+        length_ground_truth = []
+        chunk_attention_mask = []
+        chunk_labels = []
+        # max_chunk_num = 0
+        accumu_num = 0
+        slice_nums = []
+
+        # pdb.set_trace()
+        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表示在后面切一刀
+                    # pdb.set_trace()
+                    chunk_inputs_embeds[b, i] = self.encoder(
+                        inputs_embeds[b, start_position:cut].unsqueeze(0),
+                        position_embeddings=tuple(
+                            tensor[0, start_position:cut, :].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)
+
+        # only slice the first max_chunk_num chunks for each sample
+        # 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_cache_position = cache_position
+        chunk_position_embeddings = self.rotary_emb(
+            chunk_inputs_embeds, 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()
+
+        if inference:
+            # 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
+
+        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,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if use_cache:
+                next_decoder_cache = layer_outputs[
+                    2 if output_attentions else 1]
+            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(torch.bfloat16)  #这里强行变成了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()
+
+        nar_hidden_states = None
+        if not inference:
+            # NAR decoder
+            bs, length, hidden_size = hidden_states.size()
+            # assert length == max_chunk_num  # TODO: remove this
+
+            # shape: (bs * max_chunk_num) * chunk_size_limit * hidden_size
+            nat_input_embeddings = torch.zeros(
+                accumu_num, self.chunk_size_limit,
+                hidden_size).to(hidden_states.device).to(torch.bfloat16)
+            nat_attention_mask = torch.zeros(
+                accumu_num, self.chunk_size_limit).to(hidden_states.device).to(
+                    torch.bfloat16)
+            tot_chunk_num = 0
+            for b in range(bs):
+                for i in range(slice_nums[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:
+                        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
+                    else:
+                        break
+
+            nar_chunk_position = torch.arange(
+                1, self.chunk_size_limit + 1).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()
+
+            self.decoder = self.decoder.to(dtype=torch.bfloat16)
+
+            nar_hidden_states = self.decoder(
+                nat_input_embeddings,
+                attention_mask=nat_attention_mask,
+                position_embeddings=nar_position_embeddings,
+                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
+
+        # 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,
+        )
+
+
+
+
+
+class OlmoForCausalLMForSemiNAT(OlmoForCausalLM):
+
+    def __init__(self, config, *args, **kwargs):
+        super().__init__(config, *args, **kwargs)
+        self.model = OlmoModelForSemiNAT(config)
+        self.rotary_emb = OlmoRotaryEmbedding(config=config)
+        self.config = config
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size,
+                                         self.padding_idx)
+
+        self.chunk_size_limit = config.chunk_size_limit
+
+    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,
+        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,
+        cache_position: Optional[torch.LongTensor] = None,
+        logits_to_keep: Union[int, torch.Tensor] = 0,
+        **loss_kwargs,
+    ) -> 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)
+
+        # pdb.set_trace()
+
+        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,
+                cache_position=cache_position,
+            )
+        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,
+                cache_position=cache_position,
+                inference=True,
+            )
+
+        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(torch.bfloat16),
+                dim=1)
+            # 计算预测长度与真实长度之间的均方误差
+
+            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, **loss_kwargs)
+
+        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(torch.bfloat16)
+            nat_attention_mask = torch.zeros(1, self.chunk_size_limit).to(
+                input_ids.device).to(torch.bfloat16)
+
+            nat_input_embeddings[:, :
+                                 length, :] = outputs.chunk_hidden_state[:, -1, :].expand(
+                                     length, -1).to(input_ids.device).to(
+                                         torch.bfloat16)
+
+            nat_attention_mask[:, :length] = torch.tensor([1] * length).to(
+                input_ids.device).to(torch.bfloat16)
+
+            nar_chunk_position = torch.arange(
+                0, self.chunk_size_limit).unsqueeze(0).to(
+                    input_ids.device)  # bs * max_chunk_num
+
+            nar_position_embeddings = self.rotary_emb(nat_attention_mask,
+                                                      nar_chunk_position)
+
+            # pdb.set_trace()
+            nar_hidden_states = self.model.decoder(
+                nat_input_embeddings,
+                attention_mask=None,
+                position_embeddings=nar_position_embeddings,
+                output_attentions=output_attentions,
+                use_cache=False,
+                cache_position=None,
+            )
+
+            nar_hidden_states = self.model.norm(nar_hidden_states)
+            # pdb.set_trace()
+            return CausalLMOutputWithPast(
+                loss=(loss1, loss2),
+                logits=nar_hidden_states[:, :length, :],
+                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
+        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 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,
+        **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(
+            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,
+        )
+
+        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,
+            **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 _sampleforseminat(
+        self,
+        input_ids: torch.LongTensor,
+        logits_processor: LogitsProcessorList,
+        stopping_criteria: StoppingCriteriaList,
+        generation_config: GenerationConfig,
+        synced_gpus: bool,
+        streamer: Optional["BaseStreamer"],
+        **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)
+
+        ############ nar特别加的cache ############
+        # model_kwargs["nar_kv_cache"] = DynamicCache()
+        # model_kwargs["slice_pos"] = torch.tensor([[4] + [-1] * (max_length - 1)
+        #                                           ])
+
+        start = 4
+        s_pos = [start]
+        while True:
+            start += 5
+            if start > input_ids.shape[1] - 1:
+                s_pos.append(input_ids.shape[1] - 1)
+                break
+            else:
+                s_pos.append(start)
+
+        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
+
+        ############ nar特别加的cache ############
+
+        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)
+            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