# 环境：python3.9、torch1.13.1、transformers4.26.1from transformers import (    AutoTokenizer,    AutoModelForCausalLM,    LogitsProcessorList,    MinLengthLogitsProcessor,    RepetitionPenaltyLogitsProcessor,    StoppingCriteriaList,    MaxLengthCriteria,)
tokenizer = AutoTokenizer.from_pretrained("gpt2")model = AutoModelForCausalLM.from_pretrained("gpt2")
# set pad_token_id to eos_token_id because GPT2 does not have a PAD tokenmodel.generation_config.pad_token_id = model.generation_config.eos_token_id
input_prompt = "It might be possible to"input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
# instantiate logits processorslogits_processor = LogitsProcessorList(    [        MinLengthLogitsProcessor(10, eos_token_id=model.generation_config.eos_token_id),        RepetitionPenaltyLogitsProcessor(1.2),    ])stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])
outputs = model.greedy_search(    input_ids, logits_processor=logits_processor, stopping_criteria=stopping_criteria)
result = tokenizer.batch_decode(outputs, skip_special_tokens=True)print(result)-------------------------------------------------output-------------------------------------------------['It might be possible to get a better understanding of the nature of this phenomenon, but it is not']

logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
if max_length is not None:    warnings.warn(        "`max_length` is deprecated in this function, use"        " `stopping_criteria=StoppingCriteriaList([MaxLengthCriteria(max_length=max_length)])` instead.",        UserWarning,    )    stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_ideos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_idif isinstance(eos_token_id, int):    eos_token_id = [eos_token_id]output_scores = output_scores if output_scores is not None else self.generation_config.output_scoresoutput_attentions = (    output_attentions if output_attentions is not None else self.generation_config.output_attentions)output_hidden_states = (    output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states)return_dict_in_generate = (    return_dict_in_generate    if return_dict_in_generate is not None    else self.generation_config.return_dict_in_generate)
# init attention / hidden states / scores tuplesscores = () if (return_dict_in_generate and output_scores) else Nonedecoder_attentions = () if (return_dict_in_generate and output_attentions) else Nonecross_attentions = () if (return_dict_in_generate and output_attentions) else Nonedecoder_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 statesif 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    )

# keep track of which sequences are already finishedunfinished_sequences = input_ids.new(input_ids.shape[0]).fill_(1)
this_peer_finished = False  # used by synced_gpus onlywhile True:    if synced_gpus:        # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.        # The following logic allows an early break if all peers finished generating their sequence        this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)        # send 0.0 if we finished, 1.0 otherwise        dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)        # did all peers finish? the reduced sum will be 0.0 then        if this_peer_finished_flag.item() == 0.0:            break
    # prepare model inputs    model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
    # forward pass to get next token    outputs = self(        **model_inputs,        return_dict=True,        output_attentions=output_attentions,        output_hidden_states=output_hidden_states,    )
    if synced_gpus and this_peer_finished:        continue  # don't waste resources running the code we don't need
    next_token_logits = outputs.logits[:, -1, :]
    # pre-process distribution    next_tokens_scores = logits_processor(input_ids, next_token_logits)
    # Store scores, attentions and hidden_states when required    if return_dict_in_generate:        if output_scores:            scores += (next_tokens_scores,)        if output_attentions:            decoder_attentions += (                (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)            )            if self.config.is_encoder_decoder:                cross_attentions += (outputs.cross_attentions,)
        if output_hidden_states:            decoder_hidden_states += (                (outputs.decoder_hidden_states,)                if self.config.is_encoder_decoder                else (outputs.hidden_states,)            )
    # argmax    next_tokens = torch.argmax(next_tokens_scores, dim=-1)
    # finished sentences should have their next token be a padding token    if eos_token_id is not None:        if pad_token_id is None:            raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")        next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)
    # update generated ids, model inputs, and length for next step    input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)    model_kwargs = self._update_model_kwargs_for_generation(        outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder    )
    # if eos_token was found in one sentence, set sentence to finished    if eos_token_id is not None:        unfinished_sequences = unfinished_sequences.mul((sum(next_tokens != i for i in eos_token_id)).long())
    # stop when each sentence is finished, or if we exceed the maximum length    if unfinished_sequences.max() == 0 or stopping_criteria(input_ids, scores):        if not synced_gpus:            break        else:            this_peer_finished = True

class LogitsProcessorList(list):    """    This class can be used to create a list of [`LogitsProcessor`] or [`LogitsWarper`] to subsequently process a    `scores` input tensor. This class inherits from list and adds a specific *__call__* method to apply each    [`LogitsProcessor`] or [`LogitsWarper`] to the inputs.    """
    @add_start_docstrings(LOGITS_PROCESSOR_INPUTS_DOCSTRING)    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> torch.FloatTensor:        for processor in self:            function_args = inspect.signature(processor.__call__).parameters            if len(function_args) > 2:                if not all(arg in kwargs for arg in list(function_args.keys())[2:]):                    raise ValueError(                        f"Make sure that all the required parameters: {list(function_args.keys())} for "                        f"{processor.__class__} are passed to the logits processor."                    )                scores = processor(input_ids, scores, **kwargs)            else:                scores = processor(input_ids, scores)        return scores

class MinLengthLogitsProcessor(LogitsProcessor):    r"""    [`LogitsProcessor`] enforcing a min-length by setting EOS probability to 0.    Args:        min_length (`int`):            The minimum length below which the score of `eos_token_id` is set to `-float("Inf")`.        eos_token_id (`Union[int, List[int]]`):            The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.    """
    def __init__(self, min_length: int, eos_token_id: Union[int, List[int]]):        if not isinstance(min_length, int) or min_length < 0:            raise ValueError(f"`min_length` has to be a positive integer, but is {min_length}")
        if isinstance(eos_token_id, int):            eos_token_id = [eos_token_id]        if not all([isinstance(i, int) for i in eos_token_id]) or any([i < 0 for i in eos_token_id]):            raise ValueError(f"`eos_token_id` has to be a list of positive integers, but is {eos_token_id}")
        self.min_length = min_length        self.eos_token_id = eos_token_id
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:        cur_len = input_ids.shape[-1]        if cur_len < self.min_length:            for i in self.eos_token_id:                scores[:, i] = -float("inf")        return scores

class RepetitionPenaltyLogitsProcessor(LogitsProcessor):    r"""    [`LogitsProcessor`] enforcing an exponential penalty on repeated sequences.    Args:        repetition_penalty (`float`):            The parameter for repetition penalty. 1.0 means no penalty. See [this            paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.    """
    def __init__(self, penalty: float):        if not isinstance(penalty, float) or not (penalty > 0):            raise ValueError(f"`penalty` has to be a strictly positive float, but is {penalty}")
        self.penalty = penalty
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:        score = torch.gather(scores, 1, input_ids)
        # if score < 0 then repetition penalty has to be multiplied to reduce the previous token probability        score = torch.where(score < 0, score * self.penalty, score / self.penalty)
        scores.scatter_(1, input_ids, score)        return scores

if return_dict_in_generate:    if self.config.is_encoder_decoder:        return GreedySearchEncoderDecoderOutput(            sequences=input_ids,            scores=scores,            encoder_attentions=encoder_attentions,            encoder_hidden_states=encoder_hidden_states,            decoder_attentions=decoder_attentions,            cross_attentions=cross_attentions,            decoder_hidden_states=decoder_hidden_states,        )    else:        return GreedySearchDecoderOnlyOutput(            sequences=input_ids,            scores=scores,            attentions=decoder_attentions,            hidden_states=decoder_hidden_states,        )else:    return input_ids

from transformers import (    AutoTokenizer,    AutoModelForSeq2SeqLM,    LogitsProcessorList,    NoRepeatNGramLogitsProcessor,    BeamSearchScorer,)import torch
tokenizer = AutoTokenizer.from_pretrained("t5-base")model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
encoder_input_str = "translate English to Chinese: How old are you?"encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids

# lets run beam search using 3 beamsnum_beams = 3# define decoder start token idsinput_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)input_ids = input_ids * model.config.decoder_start_token_id
# add encoder_outputs to model keyword argumentsmodel_kwargs = {    "encoder_outputs": model.get_encoder()(        encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True    )}
# instantiate beam scorerbeam_scorer = BeamSearchScorer(    batch_size=1,    num_beams=num_beams,    num_beam_hyps_to_keep=2,    device=model.device,)
# instantiate logits processorslogits_processor = LogitsProcessorList(    [        NoRepeatNGramLogitsProcessor(2),    ])
outputs = model.beam_search(input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs)
result = tokenizer.batch_decode(outputs, skip_special_tokens=True))print(result)-------------------------------------------------output-------------------------------------------------['Wie alt bist du?']

batch_size = len(beam_scorer._beam_hyps)num_beams = beam_scorer.num_beams
batch_beam_size, cur_len = input_ids.shape
if num_beams * batch_size != batch_beam_size:    raise ValueError(        f"Batch dimension of `input_ids` should be {num_beams * batch_size}, but is {batch_beam_size}."    )
beam_indices = (    tuple(() for _ in range(batch_beam_size)) if (return_dict_in_generate and output_scores) else None)

# initialise score of first beam with 0 and the rest with -1e9. This makes sure that only tokens# of the first beam are considered to avoid sampling the exact same tokens across all beams.beam_scores = torch.zeros((batch_size, num_beams), dtype=torch.float, device=input_ids.device)beam_scores[:, 1:] = -1e9beam_scores = beam_scores.view((batch_size * num_beams,))
this_peer_finished = False  # used by synced_gpus onlywhile True:    if synced_gpus:        # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.        # The following logic allows an early break if all peers finished generating their sequence        this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)        # send 0.0 if we finished, 1.0 otherwise        dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)        # did all peers finish? the reduced sum will be 0.0 then        if this_peer_finished_flag.item() == 0.0:            break
    model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
    outputs = self(        **model_inputs,        return_dict=True,        output_attentions=output_attentions,        output_hidden_states=output_hidden_states,    )
    if synced_gpus and this_peer_finished:        cur_len = cur_len + 1        continue  # don't waste resources running the code we don't need
    next_token_logits = outputs.logits[:, -1, :]    # hack: adjust tokens for Marian. For Marian we have to make sure that the `pad_token_id`    # cannot be generated both before and after the `nn.functional.log_softmax` operation.    next_token_logits = self.adjust_logits_during_generation(next_token_logits, cur_len=cur_len)    next_token_scores = nn.functional.log_softmax(        next_token_logits, dim=-1    )  # (batch_size * num_beams, vocab_size)
    next_token_scores_processed = logits_processor(input_ids, next_token_scores)    next_token_scores = next_token_scores_processed + beam_scores[:, None].expand_as(next_token_scores)
    # Store scores, attentions and hidden_states when required    if return_dict_in_generate:        if output_scores:            scores += (next_token_scores_processed,)        if output_attentions:            decoder_attentions += (                (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)            )            if self.config.is_encoder_decoder:                cross_attentions += (outputs.cross_attentions,)
        if output_hidden_states:            decoder_hidden_states += (                (outputs.decoder_hidden_states,)                if self.config.is_encoder_decoder                else (outputs.hidden_states,)            )
    # reshape for beam search    vocab_size = next_token_scores.shape[-1]    next_token_scores = next_token_scores.view(batch_size, num_beams * vocab_size)
    # Sample 2 next tokens for each beam (so we have some spare tokens and match output of beam search)    next_token_scores, next_tokens = torch.topk(        next_token_scores, 2 * num_beams, dim=1, largest=True, sorted=True    )
    next_indices = torch_int_div(next_tokens, vocab_size)    next_tokens = next_tokens % vocab_size
    # stateless    beam_outputs = beam_scorer.process(        input_ids,        next_token_scores,        next_tokens,        next_indices,        pad_token_id=pad_token_id,        eos_token_id=eos_token_id,        beam_indices=beam_indices,    )
    beam_scores = beam_outputs["next_beam_scores"]    beam_next_tokens = beam_outputs["next_beam_tokens"]    beam_idx = beam_outputs["next_beam_indices"]
    input_ids = torch.cat([input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)], dim=-1)
    model_kwargs = self._update_model_kwargs_for_generation(        outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder    )    if model_kwargs["past_key_values"] is not None:        model_kwargs["past_key_values"] = self._reorder_cache(model_kwargs["past_key_values"], beam_idx)
    if return_dict_in_generate and output_scores:        beam_indices = tuple((beam_indices[beam_idx[i]] + (beam_idx[i],) for i in range(len(beam_indices))))
    # increase cur_len    cur_len = cur_len + 1
    if beam_scorer.is_done or stopping_criteria(input_ids, scores):        if not synced_gpus:            break        else:            this_peer_finished = True
sequence_outputs = beam_scorer.finalize(    input_ids,    beam_scores,    next_tokens,    next_indices,    pad_token_id=pad_token_id,    eos_token_id=eos_token_id,    max_length=stopping_criteria.max_length,    beam_indices=beam_indices,)

class NoRepeatNGramLogitsProcessor(LogitsProcessor):    r"""    [`LogitsProcessor`] that enforces no repetition of n-grams. See    [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345).    Args:        ngram_size (`int`):            All ngrams of size `ngram_size` can only occur once.    """
    def __init__(self, ngram_size: int):        if not isinstance(ngram_size, int) or ngram_size <= 0:            raise ValueError(f"`ngram_size` has to be a strictly positive integer, but is {ngram_size}")        self.ngram_size = ngram_size
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:        num_batch_hypotheses = scores.shape[0]        cur_len = input_ids.shape[-1]        banned_batch_tokens = _calc_banned_ngram_tokens(self.ngram_size, input_ids, num_batch_hypotheses, cur_len)
        for i, banned_tokens in enumerate(banned_batch_tokens):            scores[i, banned_tokens] = -float("inf")
        return scores

def _calc_banned_ngram_tokens(    ngram_size: int, prev_input_ids: torch.Tensor, num_hypos: int, cur_len: int) -> List[Iterable[int]]:    """Copied from fairseq for no_repeat_ngram in beam_search"""    if cur_len + 1 < ngram_size:        # return no banned tokens if we haven't generated no_repeat_ngram_size tokens yet        return [[] for _ in range(num_hypos)]
    generated_ngrams = _get_ngrams(ngram_size, prev_input_ids, num_hypos)
    banned_tokens = [        _get_generated_ngrams(generated_ngrams[hypo_idx], prev_input_ids[hypo_idx], ngram_size, cur_len)        for hypo_idx in range(num_hypos)    ]    return banned_tokens

def _get_ngrams(ngram_size: int, prev_input_ids: torch.Tensor, num_hypos: int):    generated_ngrams = [{} for _ in range(num_hypos)]    for idx in range(num_hypos):        gen_tokens = prev_input_ids[idx].tolist()        generated_ngram = generated_ngrams[idx]        for ngram in zip(*[gen_tokens[i:] for i in range(ngram_size)]):            prev_ngram_tuple = tuple(ngram[:-1])            generated_ngram[prev_ngram_tuple] = generated_ngram.get(prev_ngram_tuple, []) + [ngram[-1]]    return generated_ngrams

>>> gen_tokens = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> for i in range(2):...     print(gen_tokens[i:])... [1, 2, 3, 4, 5, 6, 7, 8, 9, 10][2, 3, 4, 5, 6, 7, 8, 9, 10]>>> for ngram in zip(*[gen_tokens[i:] for i in range(2)]):...     print(ngram)... (1, 2)(2, 3)(3, 4)(4, 5)(5, 6)(6, 7)(7, 8)(8, 9)(9, 10)

def _get_generated_ngrams(banned_ngrams, prev_input_ids, ngram_size, cur_len):    # Before decoding the next token, prevent decoding of ngrams that have already appeared    start_idx = cur_len + 1 - ngram_size    ngram_idx = tuple(prev_input_ids[start_idx:cur_len].tolist())    return banned_ngrams.get(ngram_idx, [])

def process(    self,    input_ids: torch.LongTensor,    next_scores: torch.FloatTensor,    next_tokens: torch.LongTensor,    next_indices: torch.LongTensor,    pad_token_id: Optional[int] = None,    eos_token_id: Optional[Union[int, List[int]]] = None,    beam_indices: Optional[torch.LongTensor] = None,) -> Tuple[torch.Tensor]:    cur_len = input_ids.shape[-1]    batch_size = len(self._beam_hyps)    if not (batch_size == (input_ids.shape[0] // self.group_size)):        if self.num_beam_groups > 1:            raise ValueError(                f"A group beam size of {input_ids.shape[0]} is used as the input, but a group beam "                f"size of {self.group_size} is expected by the beam scorer."            )        else:            raise ValueError(                f"A beam size of {input_ids.shape[0]} is used as the input, but a beam size of "                f"{self.group_size} is expected by the beam scorer."            )
    device = input_ids.device    next_beam_scores = torch.zeros((batch_size, self.group_size), dtype=next_scores.dtype, device=device)    next_beam_tokens = torch.zeros((batch_size, self.group_size), dtype=next_tokens.dtype, device=device)    next_beam_indices = torch.zeros((batch_size, self.group_size), dtype=next_indices.dtype, device=device)
    if isinstance(eos_token_id, int):        eos_token_id = [eos_token_id]
    for batch_idx, beam_hyp in enumerate(self._beam_hyps):        if self._done[batch_idx]:            if self.num_beams < len(beam_hyp):                raise ValueError(f"Batch can only be done if at least {self.num_beams} beams have been generated")            if eos_token_id is None or pad_token_id is None:                raise ValueError("Generated beams >= num_beams -> eos_token_id and pad_token have to be defined")            # pad the batch            next_beam_scores[batch_idx, :] = 0            next_beam_tokens[batch_idx, :] = pad_token_id            next_beam_indices[batch_idx, :] = 0            continue
        # next tokens for this sentence        beam_idx = 0        for beam_token_rank, (next_token, next_score, next_index) in enumerate(            zip(next_tokens[batch_idx], next_scores[batch_idx], next_indices[batch_idx])        ):            batch_beam_idx = batch_idx * self.group_size + next_index            # add to generated hypotheses if end of sentence            if (eos_token_id is not None) and (next_token.item() in eos_token_id):                # if beam_token does not belong to top num_beams tokens, it should not be added                is_beam_token_worse_than_top_num_beams = beam_token_rank >= self.group_size                if is_beam_token_worse_than_top_num_beams:                    continue                if beam_indices is not None:                    beam_index = beam_indices[batch_beam_idx]                    beam_index = beam_index + (batch_beam_idx,)                else:                    beam_index = None
                beam_hyp.add(                    input_ids[batch_beam_idx].clone(),                    next_score.item(),                    beam_indices=beam_index,                )            else:                # add next predicted token since it is not eos_token                next_beam_scores[batch_idx, beam_idx] = next_score                next_beam_tokens[batch_idx, beam_idx] = next_token                next_beam_indices[batch_idx, beam_idx] = batch_beam_idx                beam_idx += 1
            # once the beam for next step is full, don't add more tokens to it.            if beam_idx == self.group_size:                break
        if beam_idx < self.group_size:            raise ValueError(                f"At most {self.group_size} tokens in {next_tokens[batch_idx]} can be equal to `eos_token_id:"                f" {eos_token_id}`. Make sure {next_tokens[batch_idx]} are corrected."            )
        # Check if we are done so that we can save a pad step if all(done)        self._done[batch_idx] = self._done[batch_idx] or beam_hyp.is_done(            next_scores[batch_idx].max().item(), cur_len        )
    return UserDict(        {            "next_beam_scores": next_beam_scores.view(-1),            "next_beam_tokens": next_beam_tokens.view(-1),            "next_beam_indices": next_beam_indices.view(-1),        }    )

def add(self, hyp: torch.LongTensor, sum_logprobs: float, beam_indices: Optional[torch.LongTensor] = None):    """    Add a new hypothesis to the list.    """    score = sum_logprobs / (hyp.shape[-1] ** self.length_penalty)    if len(self) < self.num_beams or score > self.worst_score:        self.beams.append((score, hyp, beam_indices))        if len(self) > self.num_beams:            sorted_next_scores = sorted([(s, idx) for idx, (s, _, _) in enumerate(self.beams)])            del self.beams[sorted_next_scores[0][1]]            self.worst_score = sorted_next_scores[1][0]        else:            self.worst_score = min(score, self.worst_score)

eg1：假设self.length_penalty = 0序列1：今天天气很好（长度6，sum_logprobs=-0.6）那么score1 = -0.6 / 6 ** 0 = -0.6 / 1 = -0.6序列2：今天天气真的真的很好（长度10，sum_logprobs=-0.8）那么score2 = -0.8 / 10 ** 0 = -0.8 / 1 = -0.8此时score1 > score2，最终会选择长度更短的序列1
eg2：假设self.length_penalty = 1序列1：今天天气很好（长度6，sum_logprobs=-0.6）那么score1 = -0.6 / 6 ** 1 = -0.6 / 6 = -0.1序列2：今天天气真的真的很好（长度10，sum_logprobs=-0.8）那么score2 = -0.8 / 10 ** 1 = -0.8 / 10 = -0.08此时score2 > score1，最终会选择长度更长的序列2
eg3：假设self.length_penalty = 2候选1：今天天气很好（长度6，sum_logprobs=-0.6）那么score1 = -0.6 / 6 ** 2 = -0.6 / 36 = -0.017候选2：今天天气真的真的很好（长度10，sum_logprobs=-0.8）那么score2 = -0.8 / 10 ** 2 = -0.8 / 100 = -0.008此时score2 > score1，最终也会选择长度更长的序列2，但可以发现相比二、score2和score1的差值更大了，也就是说当self.length_penalty > 0的时候，其值越大，对长度更长的序列的得分增加的越多。

def is_done(self, best_sum_logprobs: float, cur_len: int) -> bool:    """    If there are enough hypotheses and that none of the hypotheses being generated can become better than the worst    one in the heap, then we are done with this sentence.    """
    if len(self) < self.num_beams:        return False    elif self.early_stopping:        return True    else:        cur_score = best_sum_logprobs / cur_len**self.length_penalty        ret = self.worst_score >= cur_score        return ret

def finalize(    self,    input_ids: torch.LongTensor,    final_beam_scores: torch.FloatTensor,    final_beam_tokens: torch.LongTensor,    final_beam_indices: torch.LongTensor,    max_length: int,    pad_token_id: Optional[int] = None,    eos_token_id: Optional[Union[int, List[int]]] = None,    beam_indices: Optional[torch.LongTensor] = None,) -> Tuple[torch.LongTensor]:    batch_size = len(self._beam_hyps)
    if isinstance(eos_token_id, int):        eos_token_id = [eos_token_id]
    # finalize all open beam hypotheses and add to generated hypotheses    for batch_idx, beam_hyp in enumerate(self._beam_hyps):        if self._done[batch_idx]:            continue
        # all open beam hypotheses are added to the beam hypothesis        # beam hypothesis class automatically keeps the best beams        for beam_id in range(self.num_beams):            batch_beam_idx = batch_idx * self.num_beams + beam_id            final_score = final_beam_scores[batch_beam_idx].item()            final_tokens = input_ids[batch_beam_idx]            beam_index = beam_indices[batch_beam_idx] if beam_indices is not None else None            beam_hyp.add(final_tokens, final_score, beam_indices=beam_index)
    # select the best hypotheses    sent_lengths = input_ids.new(batch_size * self.num_beam_hyps_to_keep)    best = []    best_indices = []    best_scores = torch.zeros(batch_size * self.num_beam_hyps_to_keep, device=self.device, dtype=torch.float32)
    # retrieve best hypotheses    for i, beam_hyp in enumerate(self._beam_hyps):        sorted_hyps = sorted(beam_hyp.beams, key=lambda x: x[0])        for j in range(self.num_beam_hyps_to_keep):            best_hyp_tuple = sorted_hyps.pop()            best_score = best_hyp_tuple[0]            best_hyp = best_hyp_tuple[1]            best_index = best_hyp_tuple[2]            sent_lengths[self.num_beam_hyps_to_keep * i + j] = len(best_hyp)
            # append hyp to lists            best.append(best_hyp)
            # append indices to list            best_indices.append(best_index)
            best_scores[i * self.num_beam_hyps_to_keep + j] = best_score
    # prepare for adding eos    sent_lengths_max = sent_lengths.max().item() + 1    sent_max_len = min(sent_lengths_max, max_length) if max_length is not None else sent_lengths_max    decoded: torch.LongTensor = input_ids.new(batch_size * self.num_beam_hyps_to_keep, sent_max_len)
    if len(best_indices) > 0 and best_indices[0] is not None:        indices: torch.LongTensor = input_ids.new(batch_size * self.num_beam_hyps_to_keep, sent_max_len)    else:        indices = None
    # shorter batches are padded if needed    if sent_lengths.min().item() != sent_lengths.max().item():        assert pad_token_id is not None, "`pad_token_id` has to be defined"        decoded.fill_(pad_token_id)
    if indices is not None:        indices.fill_(-1)
    # fill with hypotheses and eos_token_id if the latter fits in    for i, (hypo, best_idx) in enumerate(zip(best, best_indices)):        decoded[i, : sent_lengths[i]] = hypo
        if indices is not None:            indices[i, : len(best_idx)] = torch.tensor(best_idx)
        if sent_lengths[i] < sent_max_len:            # inserting only the first eos_token_id            decoded[i, sent_lengths[i]] = eos_token_id[0]
    return UserDict(        {            "sequences": decoded,            "sequence_scores": best_scores,            "beam_indices": indices,        }    )

  if return_dict_in_generate:        if not output_scores:            sequence_outputs["sequence_scores"] = None
        if self.config.is_encoder_decoder:            return BeamSearchEncoderDecoderOutput(                sequences=sequence_outputs["sequences"],                sequences_scores=sequence_outputs["sequence_scores"],                scores=scores,                beam_indices=sequence_outputs["beam_indices"],                encoder_attentions=encoder_attentions,                encoder_hidden_states=encoder_hidden_states,                decoder_attentions=decoder_attentions,                cross_attentions=cross_attentions,                decoder_hidden_states=decoder_hidden_states,            )        else:            return BeamSearchDecoderOnlyOutput(                sequences=sequence_outputs["sequences"],                sequences_scores=sequence_outputs["sequence_scores"],                scores=scores,                beam_indices=sequence_outputs["beam_indices"],                attentions=decoder_attentions,                hidden_states=decoder_hidden_states,            )    else:        return sequence_outputs["sequences"]

from transformers import (    AutoTokenizer,    AutoModelForCausalLM,    LogitsProcessorList,    MinLengthLogitsProcessor,    TopKLogitsWarper,    TopPLogitsWarper,    TemperatureLogitsWarper,    StoppingCriteriaList,    MaxLengthCriteria,)import torch
tokenizer = AutoTokenizer.from_pretrained("gpt2")model = AutoModelForCausalLM.from_pretrained("gpt2")
# set pad_token_id to eos_token_id because GPT2 does not have a EOS tokenmodel.config.pad_token_id = model.config.eos_token_idmodel.generation_config.pad_token_id = model.config.eos_token_id
input_prompt = "Today is a beautiful day, and"input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids
# instantiate logits processorslogits_processor = LogitsProcessorList(    [        MinLengthLogitsProcessor(15, eos_token_id=model.generation_config.eos_token_id),    ])# instantiate logits processorslogits_warper = LogitsProcessorList(    [        TopKLogitsWarper(50),        TopPLogitsWarper(0.9)    ])
stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])
torch.manual_seed(0)outputs = model.sample(    input_ids,    logits_processor=logits_processor,    logits_warper=logits_warper,    stopping_criteria=stopping_criteria,)
result = tokenizer.batch_decode(outputs, skip_special_tokens=True)print(result)-------------------------------------------------output-------------------------------------------------['Today is a beautiful day, and a wonderful day.\n\nI was lucky enough to meet the']

logits_warper = logits_warper if logits_warper is not None else LogitsProcessorList()

# keep track of which sequences are already finishedunfinished_sequences = input_ids.new(input_ids.shape[0]).fill_(1)
this_peer_finished = False  # used by synced_gpus only# auto-regressive generationwhile True:    if synced_gpus:        # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.        # The following logic allows an early break if all peers finished generating their sequence        this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)        # send 0.0 if we finished, 1.0 otherwise        dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)        # did all peers finish? the reduced sum will be 0.0 then        if this_peer_finished_flag.item() == 0.0:            break
    # prepare model inputs    model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
    # forward pass to get next token    outputs = self(        **model_inputs,        return_dict=True,        output_attentions=output_attentions,        output_hidden_states=output_hidden_states,    )
    if synced_gpus and this_peer_finished:        continue  # don't waste resources running the code we don't need
    next_token_logits = outputs.logits[:, -1, :]
    # pre-process distribution    next_token_scores = logits_processor(input_ids, next_token_logits)    next_token_scores = logits_warper(input_ids, next_token_scores)
    # Store scores, attentions and hidden_states when required    if return_dict_in_generate:        if output_scores:            scores += (next_token_scores,)        if output_attentions:            decoder_attentions += (                (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)            )            if self.config.is_encoder_decoder:                cross_attentions += (outputs.cross_attentions,)
        if output_hidden_states:            decoder_hidden_states += (                (outputs.decoder_hidden_states,)                if self.config.is_encoder_decoder                else (outputs.hidden_states,)            )
    # sample    probs = nn.functional.softmax(next_token_scores, dim=-1)    next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
    # finished sentences should have their next token be a padding token    if eos_token_id is not None:        if pad_token_id is None:            raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")        next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)
    # update generated ids, model inputs, and length for next step    input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)    model_kwargs = self._update_model_kwargs_for_generation(        outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder    )
    # if eos_token was found in one sentence, set sentence to finished    if eos_token_id is not None:        unfinished_sequences = unfinished_sequences.mul((sum(next_tokens != i for i in eos_token_id)).long())
    # stop when each sentence is finished, or if we exceed the maximum length    if unfinished_sequences.max() == 0 or stopping_criteria(input_ids, scores):        if not synced_gpus:            break        else:            this_peer_finished = True

class TopKLogitsWarper(LogitsWarper):    r"""    [`LogitsWarper`] that performs top-k, i.e. restricting to the k highest probability elements.    Args:        top_k (`int`):            The number of highest probability vocabulary tokens to keep for top-k-filtering.        filter_value (`float`, *optional*, defaults to `-float("Inf")`):            All filtered values will be set to this float value.        min_tokens_to_keep (`int`, *optional*, defaults to 1):            Minimum number of tokens that cannot be filtered.    """
    def __init__(self, top_k: int, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1):        if not isinstance(top_k, int) or top_k <= 0:            raise ValueError(f"`top_k` has to be a strictly positive integer, but is {top_k}")
        self.top_k = max(top_k, min_tokens_to_keep)        self.filter_value = filter_value
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:        top_k = min(self.top_k, scores.size(-1))  # Safety check        # Remove all tokens with a probability less than the last token of the top-k        indices_to_remove = scores < torch.topk(scores, top_k)[0][..., -1, None]        scores = scores.masked_fill(indices_to_remove, self.filter_value)        return scores

class TopPLogitsWarper(LogitsWarper):    """    [`LogitsWarper`] that performs top-p, i.e. restricting to top tokens summing to prob_cut_off <= prob_cut_off.    Args:        top_p (`float`):            If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or            higher are kept for generation.        filter_value (`float`, *optional*, defaults to `-float("Inf")`):            All filtered values will be set to this float value.        min_tokens_to_keep (`int`, *optional*, defaults to 1):            Minimum number of tokens that cannot be filtered.    """
    def __init__(self, top_p: float, filter_value: float = -float("Inf"), min_tokens_to_keep: int = 1):        top_p = float(top_p)        if top_p < 0 or top_p > 1.0:            raise ValueError(f"`top_p` has to be a float > 0 and < 1, but is {top_p}")
        self.top_p = top_p        self.filter_value = filter_value        self.min_tokens_to_keep = min_tokens_to_keep
    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:        sorted_logits, sorted_indices = torch.sort(scores, descending=False)        cumulative_probs = sorted_logits.softmax(dim=-1).cumsum(dim=-1)
        # Remove tokens with cumulative top_p above the threshold (token with 0 are kept)        sorted_indices_to_remove = cumulative_probs <= (1 - self.top_p)        if self.min_tokens_to_keep > 1:            # Keep at least min_tokens_to_keep            sorted_indices_to_remove[..., -self.min_tokens_to_keep :] = 0
        # scatter sorted tensors to original indexing        indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)        scores = scores.masked_fill(indices_to_remove, self.filter_value)        return scores

if return_dict_in_generate:    if self.config.is_encoder_decoder:        return SampleEncoderDecoderOutput(            sequences=input_ids,            scores=scores,            encoder_attentions=encoder_attentions,            encoder_hidden_states=encoder_hidden_states,            decoder_attentions=decoder_attentions,            cross_attentions=cross_attentions,            decoder_hidden_states=decoder_hidden_states,        )    else:        return SampleDecoderOnlyOutput(            sequences=input_ids,            scores=scores,            attentions=decoder_attentions,            hidden_states=decoder_hidden_states,        )else:    return input_ids

from transformers import (    AutoTokenizer,    AutoModelForSeq2SeqLM,    LogitsProcessorList,    TopKLogitsWarper,    TopPLogitsWarper,    BeamSearchScorer,)import torch
tokenizer = AutoTokenizer.from_pretrained("t5-base")model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
encoder_input_str = "translate English to German: How old are you?"encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids
# lets run beam search using 3 beamsnum_beams = 3# define decoder start token idsinput_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)input_ids = input_ids * model.config.decoder_start_token_id
# add encoder_outputs to model keyword argumentsmodel_kwargs = {    "encoder_outputs": model.get_encoder()(        encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True    )}
# instantiate beam scorerbeam_scorer = BeamSearchScorer(    batch_size=1,    max_length=model.config.max_length,    num_beams=num_beams,    device=model.device,)
# instantiate logits processorslogits_warper = LogitsProcessorList(    [        TopKLogitsWarper(50),        TopPLogitsWarper(0.9),    ])
outputs = model.beam_sample(    input_ids, beam_scorer, logits_warper=logits_warper, **model_kwargs)
result = tokenizer.batch_decode(outputs, skip_special_tokens=True)print(result)-------------------------------------------------output-------------------------------------------------['Wie alt bist du?']

beam_scores = torch.zeros((batch_size, num_beams), dtype=torch.float, device=input_ids.device)beam_scores = beam_scores.view((batch_size * num_beams,))
this_peer_finished = False  # used by synced_gpus onlywhile True:    if synced_gpus:        # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.        # The following logic allows an early break if all peers finished generating their sequence        this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)        # send 0.0 if we finished, 1.0 otherwise        dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)        # did all peers finish? the reduced sum will be 0.0 then        if this_peer_finished_flag.item() == 0.0:            break
    model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
    outputs = self(        **model_inputs,        return_dict=True,        output_attentions=output_attentions,        output_hidden_states=output_hidden_states,    )
    if synced_gpus and this_peer_finished:        cur_len = cur_len + 1        continue  # don't waste resources running the code we don't need
    next_token_logits = outputs.logits[:, -1, :]
    # hack: adjust tokens for Marian. For Marian we have to make sure that the `pad_token_id`    # cannot be generated both before and after the `nn.functional.log_softmax` operation.    next_token_logits = self.adjust_logits_during_generation(next_token_logits, cur_len=cur_len)    next_token_scores = nn.functional.log_softmax(        next_token_logits, dim=-1    )  # (batch_size * num_beams, vocab_size)
    next_token_scores_processed = logits_processor(input_ids, next_token_scores)    next_token_scores = next_token_scores_processed + beam_scores[:, None].expand_as(next_token_scores)    next_token_scores = logits_warper(input_ids, next_token_scores)
    # Store scores, attentions and hidden_states when required    if return_dict_in_generate:        if output_scores:            scores += (logits_warper(input_ids, next_token_scores_processed),)        if output_attentions:            decoder_attentions += (                (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)            )            if self.config.is_encoder_decoder:                cross_attentions += (outputs.cross_attentions,)
        if output_hidden_states:            decoder_hidden_states += (                (outputs.decoder_hidden_states,)                if self.config.is_encoder_decoder                else (outputs.hidden_states,)            )
    # reshape for beam search    vocab_size = next_token_scores.shape[-1]    next_token_scores = next_token_scores.view(batch_size, num_beams * vocab_size)
    probs = nn.functional.softmax(next_token_scores, dim=-1)
    next_tokens = torch.multinomial(probs, num_samples=2 * num_beams)    next_token_scores = torch.gather(next_token_scores, -1, next_tokens)
    next_token_scores, _indices = torch.sort(next_token_scores, descending=True, dim=1)    next_tokens = torch.gather(next_tokens, -1, _indices)
    next_indices = torch_int_div(next_tokens, vocab_size)    next_tokens = next_tokens % vocab_size
    # stateless    beam_outputs = beam_scorer.process(        input_ids,        next_token_scores,        next_tokens,        next_indices,        pad_token_id=pad_token_id,        eos_token_id=eos_token_id,        beam_indices=beam_indices,    )    beam_scores = beam_outputs["next_beam_scores"]    beam_next_tokens = beam_outputs["next_beam_tokens"]    beam_idx = beam_outputs["next_beam_indices"]
    input_ids = torch.cat([input_ids[beam_idx, :], beam_next_tokens.unsqueeze(-1)], dim=-1)
    model_kwargs = self._update_model_kwargs_for_generation(        outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder    )    if model_kwargs["past_key_values"] is not None:        model_kwargs["past_key_values"] = self._reorder_cache(model_kwargs["past_key_values"], beam_idx)
    if return_dict_in_generate and output_scores:        beam_indices = tuple((beam_indices[beam_idx[i]] + (beam_idx[i],) for i in range(len(beam_indices))))
    # increase cur_len    cur_len = cur_len + 1
    if beam_scorer.is_done or stopping_criteria(input_ids, scores):        if not synced_gpus:            break        else:            this_peer_finished = True
sequence_outputs = beam_scorer.finalize(    input_ids,    beam_scores,    next_tokens,    next_indices,    pad_token_id=pad_token_id,    eos_token_id=eos_token_id,    max_length=stopping_criteria.max_length,    beam_indices=beam_indices,)

if return_dict_in_generate:    if not output_scores:        sequence_outputs["sequence_scores"] = None
    if self.config.is_encoder_decoder:        return BeamSampleEncoderDecoderOutput(            sequences=sequence_outputs["sequences"],            sequences_scores=sequence_outputs["sequence_scores"],            scores=scores,            beam_indices=sequence_outputs["beam_indices"],            encoder_attentions=encoder_attentions,            encoder_hidden_states=encoder_hidden_states,            decoder_attentions=decoder_attentions,            cross_attentions=cross_attentions,            decoder_hidden_states=decoder_hidden_states,        )    else:        return BeamSampleDecoderOnlyOutput(            sequences=sequence_outputs["sequences"],            sequences_scores=sequence_outputs["sequence_scores"],            scores=scores,            beam_indices=sequence_outputs["beam_indices"],            attentions=decoder_attentions,            hidden_states=decoder_hidden_states,        )else:    return sequence_outputs["sequences"]

from transformers import (    AutoTokenizer,    AutoModelForSeq2SeqLM,    LogitsProcessorList,    MinLengthLogitsProcessor,    HammingDiversityLogitsProcessor,    BeamSearchScorer,)import torch
tokenizer = AutoTokenizer.from_pretrained("t5-base")model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
encoder_input_str = "translate English to German: How old are you?"encoder_input_ids = tokenizer(encoder_input_str, return_tensors="pt").input_ids

# lets run diverse beam search using 6 beamsnum_beams = 6# define decoder start token idsinput_ids = torch.ones((num_beams, 1), device=model.device, dtype=torch.long)input_ids = input_ids * model.config.decoder_start_token_id
# add encoder_outputs to model keyword argumentsmodel_kwargs = {    "encoder_outputs": model.get_encoder()(        encoder_input_ids.repeat_interleave(num_beams, dim=0), return_dict=True    )}
# instantiate beam scorerbeam_scorer = BeamSearchScorer(    batch_size=1,    max_length=model.config.max_length,    num_beams=num_beams,    device=model.device,    num_beam_groups=3,    num_beam_hyps_to_keep=2,)
# instantiate logits processorslogits_processor = LogitsProcessorList(    [        HammingDiversityLogitsProcessor(5.5, num_beams=6, num_beam_groups=3),    ])
outputs = model.group_beam_search(    input_ids, beam_scorer, logits_processor=logits_processor, **model_kwargs)
result = tokenizer.batch_decode(outputs, skip_special_tokens=True)print(result)-------------------------------------------------output-------------------------------------------------['Wie alt bist du?', 'Wie alt sind Sie?']