Utilities for Generation
Utilities for Generation
This page lists all the utility functions used by generate(), greedy_search(), contrastive_search(), sample(), beam_search(), beam_sample(), group_beam_search(), and constrained_beam_search().
Most of those are only useful if you are studying the code of the generate methods in the library.
Generate Outputs
The output of generate() is an instance of a subclass of ModelOutput. This output is a data structure containing all the information returned by generate(), but that can also be used as tuple or dictionary.
Hereβs an example:
Copied
The generation_output
object is a GreedySearchDecoderOnlyOutput, as we can see in the documentation of that class below, it means it has the following attributes:
sequences
: the generated sequences of tokensscores
(optional): the prediction scores of the language modelling head, for each generation stephidden_states
(optional): the hidden states of the model, for each generation stepattentions
(optional): the attention weights of the model, for each generation step
Here we have the scores
since we passed along output_scores=True
, but we donβt have hidden_states
and attentions
because we didnβt pass output_hidden_states=True
or output_attentions=True
.
You can access each attribute as you would usually do, and if that attribute has not been returned by the model, you will get None
. Here for instance generation_output.scores
are all the generated prediction scores of the language modeling head, and generation_output.attentions
is None
.
When using our generation_output
object as a tuple, it only keeps the attributes that donβt have None
values. Here, for instance, it has two elements, loss
then logits
, so
Copied
will return the tuple (generation_output.sequences, generation_output.scores)
for instance.
When using our generation_output
object as a dictionary, it only keeps the attributes that donβt have None
values. Here, for instance, it has two keys that are sequences
and scores
.
We document here all output types.
PyTorch
class transformers.generation.GreedySearchEncoderDecoderOutput
( sequences: LongTensor = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.encoder_attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftorch.FloatTensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using greedy search. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.GreedySearchDecoderOnlyOutput
( sequences: LongTensor = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using greedy search.
class transformers.generation.SampleEncoderDecoderOutput
( sequences: LongTensor = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_return_sequences, config.vocab_size)
.encoder_attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftorch.FloatTensor
(one for each layer of the decoder) of shape(batch_size*num_return_sequences, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size*num_return_sequences, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_return_sequences, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_return_sequences, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using sampling. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.SampleDecoderOnlyOutput
( sequences: LongTensor = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_return_sequences, config.vocab_size)
.attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(num_return_sequences*batch_size, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(num_return_sequences*batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using sampling.
class transformers.generation.BeamSearchEncoderDecoderOutput
( sequences: LongTensor = Nonesequences_scores: typing.Optional[torch.FloatTensor] = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonebeam_indices: typing.Optional[torch.LongTensor] = Noneencoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
torch.FloatTensor
of shape(batch_size*num_return_sequences)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam transition scores for each vocabulary token at each generation step. Beam transition scores consisting of log probabilities of tokens conditioned on log softmax of previously generated tokens in this beam. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams, config.vocab_size)
.beam_indices (
torch.LongTensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
.encoder_attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftorch.FloatTensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using beam search. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.BeamSearchDecoderOnlyOutput
( sequences: LongTensor = Nonesequences_scores: typing.Optional[torch.FloatTensor] = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonebeam_indices: typing.Optional[torch.LongTensor] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
torch.FloatTensor
of shape(batch_size*num_return_sequences)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam transition scores for each vocabulary token at each generation step. Beam transition scores consisting of log probabilities of tokens conditioned on log softmax of previously generated tokens in this beam. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams*num_return_sequences, config.vocab_size)
.beam_indices (
torch.LongTensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
.attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using beam search.
class transformers.generation.BeamSampleEncoderDecoderOutput
( sequences: LongTensor = Nonesequences_scores: typing.Optional[torch.FloatTensor] = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonebeam_indices: typing.Optional[torch.LongTensor] = Noneencoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size*num_beams, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
torch.FloatTensor
of shape(batch_size * num_return_sequence)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam transition scores for each vocabulary token at each generation step. Beam transition scores consisting of log probabilities of tokens conditioned on log softmax of previously generated tokens in this beam. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams, config.vocab_size)
).beam_indices (
torch.LongTensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
.encoder_attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftorch.FloatTensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size*num_beams, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using beam sampling. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.BeamSampleDecoderOnlyOutput
( sequences: LongTensor = Nonesequences_scores: typing.Optional[torch.FloatTensor] = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonebeam_indices: typing.Optional[torch.LongTensor] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
torch.FloatTensor
of shape(batch_size * num_return_sequence)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam transition scores for each vocabulary token at each generation step. Beam transition scores consisting of log probabilities of tokens conditioned on log softmax of previously generated tokens in this beam. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams*num_return_sequences, config.vocab_size)
.beam_indices (
torch.LongTensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.torch.LongTensor
of shape(batch_size*num_return_sequences, sequence_length)
.attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size*num_beams, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using beam sample.
class transformers.generation.ContrastiveSearchEncoderDecoderOutput
( sequences: LongTensor = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.encoder_attentions (
tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftorch.FloatTensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using contrastive search.
class transformers.generation.ContrastiveSearchDecoderOnlyOutput
( sequences: LongTensor = Nonescores: typing.Optional[typing.Tuple[torch.FloatTensor]] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None )
Parameters
sequences (
torch.LongTensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(torch.FloatTensor)
optional, returned whenoutput_scores=True
is passed or when βconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftorch.FloatTensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.attentions (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(torch.FloatTensor))
, optional, returned whenoutput_hidden_states=True
is βpassed or when
config.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftorch.FloatTensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using contrastive search.
TensorFlow
class transformers.generation.TFGreedySearchEncoderDecoderOutput
( sequences: Tensor = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.encoder_attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftf.Tensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using greedy search. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.TFGreedySearchDecoderOnlyOutput
( sequences: Tensor = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using greedy search.
class transformers.generation.TFSampleEncoderDecoderOutput
( sequences: Tensor = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_return_sequences, config.vocab_size)
.encoder_attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftf.Tensor
(one for each layer of the decoder) of shape(batch_size*num_return_sequences, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size*num_return_sequences, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_return_sequences, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_return_sequences, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using sampling. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.TFSampleDecoderOnlyOutput
( sequences: Tensor = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_return_sequences, config.vocab_size)
.attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(num_return_sequences*batch_size, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(num_return_sequences*batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using sampling.
class transformers.generation.TFBeamSearchEncoderDecoderOutput
( sequences: Tensor = Nonesequences_scores: typing.Optional[tensorflow.python.framework.ops.Tensor] = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonebeam_indices: typing.Optional[tensorflow.python.framework.ops.Tensor] = Noneencoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
tf.Tensor
of shape(batch_size*num_return_sequences)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this beam.Tuple of
tf.Tensorwith up to
max_new_tokenselements (one element for each generated token), with each tensor of shape
(batch_size*num_beams, config.vocab_size)`.beam_indices (
tf.Tensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
.encoder_attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftf.Tensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using beam search. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.TFBeamSearchDecoderOnlyOutput
( sequences: Tensor = Nonesequences_scores: typing.Optional[tensorflow.python.framework.ops.Tensor] = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonebeam_indices: typing.Optional[tensorflow.python.framework.ops.Tensor] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
tf.Tensor
of shape(batch_size*num_return_sequences)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this beam. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams*num_return_sequences, config.vocab_size)
.beam_indices (
tf.Tensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
.attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using beam search.
class transformers.generation.TFBeamSampleEncoderDecoderOutput
( sequences: Tensor = Nonesequences_scores: typing.Optional[tensorflow.python.framework.ops.Tensor] = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonebeam_indices: typing.Optional[tensorflow.python.framework.ops.Tensor] = Noneencoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size*num_beams, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
tf.Tensor
of shape(batch_size * num_return_sequence)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this beam. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams, config.vocab_size)
.beam_indices (
tf.Tensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
.encoder_attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftf.Tensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size*num_beams, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using beam sampling. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.TFBeamSampleDecoderOnlyOutput
( sequences: Tensor = Nonesequences_scores: typing.Optional[tensorflow.python.framework.ops.Tensor] = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonebeam_indices: typing.Optional[tensorflow.python.framework.ops.Tensor] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.sequences_scores (
tf.Tensor
of shape(batch_size * num_return_sequence)
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Final beam scores of the generatedsequences
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed beam scores for each vocabulary token at each generation step. Beam scores consisting of log softmax scores for each vocabulary token and sum of log softmax of previously generated tokens in this beam. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size*num_beams*num_return_sequences, config.vocab_size)
.beam_indices (
tf.Tensor
, optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Beam indices of generated token id at each generation step.tf.Tensor
of shape(batch_size*num_return_sequences, sequence_length)
.attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size*num_beams, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using beam sample.
class transformers.generation.TFContrastiveSearchEncoderDecoderOutput
( sequences: Tensor = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_attentions: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneencoder_hidden_states: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Nonedecoder_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonecross_attentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonedecoder_hidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.encoder_attentions (
tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple oftf.Tensor
(one for each layer of the decoder) of shape(batch_size, num_heads, sequence_length, sequence_length)
.encoder_hidden_states (
tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple oftf.Tensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
.decoder_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.cross_attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.decoder_hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of encoder-decoder generation models using contrastive search. Hidden states and attention weights of the decoder (respectively the encoder) can be accessed via the encoder_attentions and the encoder_hidden_states attributes (respectively the decoder_attentions and the decoder_hidden_states attributes)
class transformers.generation.TFContrastiveSearchDecoderOnlyOutput
( sequences: Tensor = Nonescores: typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = Noneattentions: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = Nonehidden_states: typing.Optional[typing.Tuple[typing.Tuple[tensorflow.python.framework.ops.Tensor]]] = None )
Parameters
sequences (
tf.Tensor
of shape(batch_size, sequence_length)
) β The generated sequences. The second dimension (sequence_length) is either equal tomax_length
or shorter if all batches finished early due to theeos_token_id
.scores (
tuple(tf.Tensor)
optional, returned whenoutput_scores=True
is passed or whenconfig.output_scores=True
) β Processed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax) at each generation step. Tuple oftf.Tensor
with up tomax_new_tokens
elements (one element for each generated token), with each tensor of shape(batch_size, config.vocab_size)
.attentions (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_attentions=True
is passed orconfig.output_attentions=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, num_heads, generated_length, sequence_length)
.hidden_states (
tuple(tuple(tf.Tensor))
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) β Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) oftf.Tensor
of shape(batch_size, generated_length, hidden_size)
.
Base class for outputs of decoder-only generation models using contrastive search.
FLAX
class transformers.generation.FlaxSampleOutput
( sequences: Array = None )
Parameters
sequences (
jnp.ndarray
of shape(batch_size, max_length)
) β The generated sequences.
Flax Base class for outputs of decoder-only generation models using sampling.
replace
( **updates )
βReturns a new object replacing the specified fields with new values.
class transformers.generation.FlaxGreedySearchOutput
( sequences: Array = None )
Parameters
sequences (
jnp.ndarray
of shape(batch_size, max_length)
) β The generated sequences.
Flax Base class for outputs of decoder-only generation models using greedy search.
replace
( **updates )
βReturns a new object replacing the specified fields with new values.
class transformers.generation.FlaxBeamSearchOutput
( sequences: Array = Nonescores: Array = None )
Parameters
sequences (
jnp.ndarray
of shape(batch_size, max_length)
) β The generated sequences.scores (
jnp.ndarray
of shape(batch_size,)
) β The scores (log probabilities) of the generated sequences.
Flax Base class for outputs of decoder-only generation models using greedy search.
replace
( **updates )
βReturns a new object replacing the specified fields with new values.
LogitsProcessor
A LogitsProcessor can be used to modify the prediction scores of a language model head for generation.
PyTorch
class transformers.AlternatingCodebooksLogitsProcessor
( input_start_len: intsemantic_vocab_size: intcodebook_size: int )
Parameters
input_start_len (
int
) β The length of the initial input sequence.semantic_vocab_size (
int
) β Vocabulary size of the semantic part, i.e number of tokens associated to the semantic vocabulary.codebook_size (
int
) β Number of tokens associated to the codebook.
LogitsProcessor enforcing alternated generation between the two codebooks of Bark
βs fine submodel.
__call__
( input_ids: LongTensorscores: FloatTensor )
class transformers.ClassifierFreeGuidanceLogitsProcessor
( guidance_scale )
Parameters
guidance_scale (float) β The guidance scale for classifier free guidance (CFG). CFG is enabled by setting
guidance_scale > 1
. Higher guidance scale encourages the model to generate samples that are more closely linked to the input prompt, usually at the expense of poorer quality.
Logits processor for classifier free guidance (CFG). The scores are split over the batch dimension, where the first half correspond to the conditional logits (predicted from the input prompt) and the second half correspond to the unconditional logits (predicted from an empty or βnullβ prompt). The processor computes a weighted average across the conditional and unconditional logits, parameterised by the guidance_scale
.
See the paper for more information.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.EncoderNoRepeatNGramLogitsProcessor
( encoder_ngram_size: intencoder_input_ids: LongTensor )
Parameters
encoder_ngram_size (
int
) β All ngrams of sizengram_size
can only occur within the encoder input ids.encoder_input_ids (
int
) β The encoder_input_ids that should not be repeated within the decoder ids.
LogitsProcessor that enforces no repetition of encoder input ids n-grams for the decoder ids. See ParlAI.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.EncoderRepetitionPenaltyLogitsProcessor
( penalty: floatencoder_input_ids: LongTensor )
Parameters
hallucination_penalty (
float
) β The parameter for hallucination penalty. 1.0 means no penalty.encoder_input_ids (
torch.LongTensor
) β The encoder_input_ids that should be repeated within the decoder ids.
LogitsProcessor enforcing an exponential penalty on tokens that are not in the original input.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.EpsilonLogitsWarper
( epsilon: floatfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
epsilon (
float
) β If set to > 0, only the most tokens with probabilitiesepsilon
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.
LogitsWarper that performs epsilon-sampling, i.e. restricting to tokens with prob >= epsilon
. Takes the largest min_tokens_to_keep tokens if no tokens satisfy this constraint. See Truncation Sampling as Language Model Desmoothing for more information.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.EtaLogitsWarper
( epsilon: floatfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
epsilon (
float
) β A float value in the range (0, 1). Hyperparameter used to calculate the dynamic cutoff value,eta
. The suggested values from the paper ranges from 3e-4 to 4e-3 depending on the size of the model.filter_value (
float
, optional, defaults to-float("Inf")
) β All values that are found to be below the dynamic cutoff value,eta
, are set to this float value. This parameter is useful when logits need to be modified for very low probability tokens that should be excluded from generation entirely.min_tokens_to_keep (
int
, optional, defaults to 1) β Specifies the minimum number of tokens that must be kept for generation, regardless of their probabilities. For example, ifmin_tokens_to_keep
is set to 1, at least one token will always be kept for generation, even if all tokens have probabilities below the cutoffeta
.
LogitsWarper that performs eta-sampling, a technique to filter out tokens with probabilities below a dynamic cutoff value, eta
, which is calculated based on a combination of the hyperparameter epsilon
and the entropy of the token probabilities, i.e. eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))
. Takes the largest min_tokens_to_keep tokens if no tokens satisfy this constraint. It addresses the issue of poor quality in long samples of text generated by neural language models leading to more coherent and fluent text. See Truncation Sampling as Language Model Desmoothing for more information. Note: do_sample
must be set to True
for this LogitsWarper
to work.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.ExponentialDecayLengthPenalty
( exponential_decay_length_penalty: typing.Tuple[int, float]eos_token_id: typing.Union[int, typing.List[int]]input_ids_seq_length: int )
Parameters
exponential_decay_length_penalty (
tuple(int, float)
) β This tuple shall consist of:(start_index, decay_factor)
wherestart_index
indicates where penalty starts anddecay_factor
represents the factor of exponential decayeos_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.input_ids_seq_length (
int
) β The length of the input sequence.
LogitsProcessor that exponentially increases the score of the eos_token_id
after start_index
has been reached. This allows generating shorter sequences without having a hard cutoff, allowing the eos_token
to be predicted in a meaningful position.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.ForcedBOSTokenLogitsProcessor
( bos_token_id: int )
Parameters
bos_token_id (
int
) β The id of the token to force as the first generated token.
LogitsProcessor that enforces the specified token as the first generated token.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.ForcedEOSTokenLogitsProcessor
( max_length: inteos_token_id: typing.Union[int, typing.List[int]] )
Parameters
max_length (
int
) β The maximum length of the sequence to be generated.eos_token_id (
Union[int, List[int]]
) β The id of the token to force as the last generated token whenmax_length
is reached. Optionally, use a list to set multiple end-of-sequence tokens.
LogitsProcessor that enforces the specified token as the last generated token when max_length
is reached.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.ForceTokensLogitsProcessor
( force_token_map: typing.List[typing.List[int]] )
This processor takes a list of pairs of integers which indicates a mapping from generation indices to token indices that will be forced before sampling. The processor will set their log probs to inf
so that they are sampled at their corresponding index.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.HammingDiversityLogitsProcessor
( diversity_penalty: floatnum_beams: intnum_beam_groups: int )
Parameters
diversity_penalty (
float
) β This value is subtracted from a beamβs score if it generates a token same as any beam from other group at a particular time. Note thatdiversity_penalty
is only effective if group beam search is enabled. The penalty applied to a beamβs score when it generates a token that has already been chosen by another beam within the same group during the same time step. A higherdiversity_penalty
will enforce greater diversity among the beams, making it less likely for multiple beams to choose the same token. Conversely, a lower penalty will allow beams to more freely choose similar tokens. Adjusting this value can help strike a balance between diversity and natural likelihood.num_beams (
int
) β Number of beams used for group beam search. Beam search is a method used that maintains beams (or βmultiple hypothesesβ) at each step, expanding each one and keeping the top-scoring sequences. A highernum_beams
will explore more potential sequences. This can increase chances of finding a high-quality output but also increases computational cost.num_beam_groups (
int
) β Number of groups to dividenum_beams
into in order to ensure diversity among different groups of beams. Each group of beams will operate independently, selecting tokens without considering the choices of other groups. This division promotes diversity by ensuring that beams within different groups explore different paths. For instance, ifnum_beams
is 6 andnum_beam_groups
is 2, there will be 2 groups each containing 3 beams. The choice ofnum_beam_groups
should be made considering the desired level of output diversity and the total number of beams. See this paper for more details.
LogitsProcessor that enforces diverse beam search.
Note that this logits processor is only effective for PreTrainedModel.group_beam_search(). See Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence Models for more details.
Diverse beam search can be particularly useful in scenarios where a variety of different outputs is desired, rather than multiple similar sequences. It allows the model to explore different generation paths and provides a broader coverage of possible outputs.
This logits processor can be resource-intensive, especially when using large models or long sequences.
Traditional beam search often generates very similar sequences across different beams. HammingDiversityLogitsProcessor
addresses this by penalizing beams that generate tokens already chosen by other beams in the same time step.
How It Works:
Grouping Beams: Beams are divided into groups. Each group selects tokens independently of the others.
Penalizing Repeated Tokens: If a beam in a group selects a token already chosen by another group in the same step, a penalty is applied to that tokenβs score.
Promoting Diversity: This penalty discourages beams within a group from selecting the same tokens as beams in other groups.
Benefits:
Diverse Outputs: Produces a variety of different sequences.
Exploration: Allows the model to explore different paths.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensorcurrent_tokens: LongTensorbeam_group_idx: int ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam searchcurrent_tokens (
torch.LongTensor
of shape(batch_size)
) β Indices of input sequence tokens in the vocabulary, corresponding to the tokens selected by the other beam groups in the current generation step.beam_group_idx (
int
) β The index of the beam group currently being processed.
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.InfNanRemoveLogitsProcessor
( )
LogitsProcessor that removes all nan
and inf
values to avoid the generation method to fail. Note that using the logits processor should only be used if necessary since it can slow down the generation method.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.LogitNormalization
( )
LogitsWarper and LogitsProcessor for normalizing the scores using log-softmax. Itβs important to normalize the scores during beam search, after applying the logits processors or warpers, since the search algorithm used in this library doesnβt do it (it only does it before, but they may need re-normalization) but it still supposes that the scores are normalized when comparing the hypotheses.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.LogitsProcessor
( )
Abstract base class for all logit processors that can be applied during generation.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.LogitsProcessorList
( iterable = () )
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.
__call__
( input_ids: LongTensorscores: FloatTensor**kwargs ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam searchkwargs (
Dict[str, Any]
, optional) β Additional kwargs that are specific to a logits processor.
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.LogitsWarper
( )
Abstract base class for all logit warpers that can be applied during generation with multinomial sampling.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.MinLengthLogitsProcessor
( min_length: inteos_token_id: typing.Union[int, typing.List[int]] )
Parameters
min_length (
int
) β The minimum length below which the score ofeos_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.
LogitsProcessor enforcing a min-length by setting EOS probability to 0.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.MinNewTokensLengthLogitsProcessor
( prompt_length_to_skip: intmin_new_tokens: inteos_token_id: typing.Union[int, typing.List[int]] )
Parameters
prompt_length_to_skip (
int
) β The input tokens length. Not a valid argument when used withgenerate
as it will automatically assign the input length.min_new_tokens (
int
) β The minimum new tokens length below which the score ofeos_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.
LogitsProcessor enforcing a min-length of new tokens by setting EOS (End-Of-Sequence) token probability to 0. Note that for decoder-only models, such as Llama2, min_length
will compute the length of prompt + newly generated tokens
whereas for other models it will behave as min_new_tokens
, that is, taking only into account the newly generated ones.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.NoBadWordsLogitsProcessor
( bad_words_ids: typing.List[typing.List[int]]eos_token_id: typing.Union[int, typing.List[int]] )
Parameters
bad_words_ids (
List[List[int]]
) β List of list of token ids that are not allowed to be generated.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.
LogitsProcessor that enforces that specified sequences will never be selected.
In order to get the token ids of the words that should not appear in the generated text, make sure to set add_prefix_space=True
when initializing the tokenizer, and use tokenizer(bad_words, add_special_tokens=False).input_ids
. The add_prefix_space
argument is only supported for some slow tokenizers, as fast tokenizersβ prefixing behaviours come from pre tokenizers
. Read more here.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.NoRepeatNGramLogitsProcessor
( ngram_size: int )
Parameters
ngram_size (
int
) β All ngrams of sizengram_size
can only occur once.
N-grams are groups of βnβ consecutive words, characters, or tokens taken from a sequence of text. Given the sentence: βShe runs fastβ, the bi-grams (n=2) would be (βsheβ, βrunsβ) and (βrunsβ, βfastβ). In text generation, avoiding repetitions of word sequences provides a more diverse output. This LogitsProcessor enforces no repetition of n-grams by setting the scores of banned tokens to negative infinity which eliminates those tokens from consideration when further processing the scores. Fairseq.
Use n-gram penalties with care. For instance, penalizing 2-grams (bigrams) in an article about the city of New York might lead to undesirable outcomes where the cityβs name appears only once in the entire text. Reference
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.PrefixConstrainedLogitsProcessor
( prefix_allowed_tokens_fn: typing.Callable[[int, torch.Tensor], typing.List[int]]num_beams: int )
Parameters
prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], List[int]]
) β This function constraints the beam search to allowed tokens only at each step. This function takes 2 argumentsinputs_ids
and the batch IDbatch_id
. It has to return a list with the allowed tokens for the next generation step conditioned on the previously generated tokensinputs_ids
and the batch IDbatch_id
.
LogitsProcessor that enforces constrained generation and is useful for prefix-conditioned constrained generation. See Autoregressive Entity Retrieval for more information.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.RepetitionPenaltyLogitsProcessor
( penalty: float )
Parameters
repetition_penalty (
float
) β The parameter for repetition penalty. 1.0 means no penalty. See this paper for more details.
LogitsProcessor that prevents the repetition of previous tokens through an exponential penalty. This technique shares some similarities with coverage mechanisms and other aimed at reducing repetition. During the text generation process, the probability distribution for the next token is determined using a formula that incorporates token scores based on their occurrence in the generated sequence. Tokens with higher scores are more likely to be selected. The formula can be seen in the original paper. According to the paper a penalty of around 1.2 yields a good balance between truthful generation and lack of repetition.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.SequenceBiasLogitsProcessor
( sequence_bias: typing.Dict[typing.Tuple[int], float] )
Parameters
sequence_bias (
Dict[Tuple[int], float]
) β Dictionary that maps a sequence of tokens to its bias term. Positive biases increase the odds of the sequence being selected, while negative biases do the opposite. If a sequence has a length of 1, its bias will always be applied. Otherwise, the bias will only be applied if the sequence in question is about to be completed (in the token selection step after this processor is applied).
LogitsProcessor that applies an additive bias on sequences. The bias is applied to the last token of a sequence when the next generated token can complete it. Consequently, to take the most of biasing sequences with more than one token, consider using beam methods (to gracefully work around partially completed sequences that have a negative bias) and applying the bias to their prefixes (to ensure the bias is applied earlier).
In order to get the token ids of the sequences that you want to bias, make sure to set add_prefix_space=True
when initializing the tokenizer, and use tokenizer(bad_words, add_special_tokens=False).input_ids
. The add_prefix_space
argument is only supported for some slow tokenizers, as fast tokenizersβ prefixing behaviours come from pre tokenizers
. Read more here.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.SuppressTokensAtBeginLogitsProcessor
( begin_suppress_tokensbegin_index )
SuppressTokensAtBeginLogitsProcessor supresses a list of tokens as soon as the generate
function starts generating using begin_index
tokens. This should ensure that the tokens defined by begin_suppress_tokens
at not sampled at the begining of the generation.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.SuppressTokensLogitsProcessor
( suppress_tokens )
This processor can be used to suppress a list of tokens. The processor will set their log probs to -inf
so that they are not sampled.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.TemperatureLogitsWarper
( temperature: float )
Parameters
temperature (
float
) β Strictly positive float value used to modulate the logits distribution. A value smaller than1
decreases randomness (and vice versa), with0
being equivalent to shifting all probability mass to the most likely token.
LogitsWarper for temperature (exponential scaling output probability distribution), which effectively means that it can control the randomness of the predicted tokens.
Make sure that do_sample=True
is included in the generate
arguments otherwise the temperature value wonβt have any effect.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.TopKLogitsWarper
( top_k: intfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
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.
LogitsWarper that performs top-k, i.e. restricting to the k highest probability elements.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.TopPLogitsWarper
( top_p: floatfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
top_p (
float
) β If set to < 1, only the smallest set of most probable tokens with probabilities that add up totop_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.
LogitsWarper that performs top-p, i.e. restricting to top tokens summing to prob_cut_off <= prob_cut_off.
Examples:
Copied
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.TypicalLogitsWarper
( mass: float = 0.9filter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
mass (
float
) β Value of typical_p between 0 and 1 inclusive, defaults to 0.9.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.
LogitsWarper that performs typical decoding. See Typical Decoding for Natural Language Generation for more information.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor
( guidance_scale: floatmodelunconditional_ids: typing.Optional[torch.LongTensor] = Noneunconditional_attention_mask: typing.Optional[torch.LongTensor] = Noneuse_cache: typing.Optional[bool] = True )
Parameters
guidance_scale (
float
) β The guidance scale for classifier free guidance (CFG). CFG is enabled by settingguidance_scale != 1
. Higher guidance scale encourages the model to generate samples that are more closely linked to the input prompt, usually at the expense of poorer quality. A value smaller than 1 has the opposite effect, while making the negative prompt provided with negative_prompt_ids (if any) act as a positive prompt.unconditional_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) β Indices of input sequence tokens in the vocabulary for the unconditional branch. If unset, will default to the last token of the prompt.unconditional_attention_mask (
torch.LongTensor
of shape(batch_size, sequence_length)
, optional) β Attention mask for unconditional_ids.model (
PreTrainedModel
) β The model computing the unconditional scores. Supposedly the same as the one computing the conditional scores. Both models must use the same tokenizer.smooth_factor (
float
, optional) β The interpolation weight for CFG Rescale. 1 means no rescaling, 0 reduces to the conditional scores without CFG. Turn it lower if the output degenerates.use_cache (
bool
, optional) β Whether to cache key/values during the negative prompt forward pass.
Logits processor for Classifier-Free Guidance (CFG). The processors computes a weighted average across scores from prompt conditional and prompt unconditional (or negative) logits, parameterized by the guidance_scale
. The unconditional scores are computed internally by prompting model
with the unconditional_ids
branch.
See the paper for more information.
Examples:
Copied
__call__
( input_idsscores )
class transformers.WhisperTimeStampLogitsProcessor
( generate_config )
Parameters
generate_config (
GenerateConfig
) β The generate config used to generate the output. The following parameters are required: eos_token_id (int
, optional, defaults to 50257): The id of the end-of-sequence token. no_timestamps_token_id (int
, optional, defaults to 50363): The id of the"<|notimestamps|>"
token. max_initial_timestamp_index (int
, optional, defaults to 1): Used to set the maximum value of the initial timestamp. This is used to prevent the model from predicting timestamps that are too far in the future.
Whisper specific Processor. This processor can be used to force a list of tokens. The processor will set their log probs to inf
so that they are sampled at their corresponding index.
See the paper for more information.
__call__
( input_ids: LongTensorscores: FloatTensor ) β torch.FloatTensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary. What are input IDs?scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search
Returns
torch.FloatTensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
TensorFlow
class transformers.TFForcedBOSTokenLogitsProcessor
( bos_token_id: int )
Parameters
bos_token_id (
int
) β The id of the token to force as the first generated token.
TFLogitsProcessor that enforces the specified token as the first generated token.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFForcedEOSTokenLogitsProcessor
( max_length: inteos_token_id: int )
Parameters
max_length (
int
) β The maximum length of the sequence to be generated.eos_token_id (
int
) β The id of the token to force as the last generated token whenmax_length
is reached.
TFLogitsProcessor that enforces the specified token as the last generated token when max_length
is reached.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFForceTokensLogitsProcessor
( force_token_map: typing.List[typing.List[int]] )
This processor takes a list of pairs of integers which indicates a mapping from generation indices to token indices that will be forced before sampling. The processor will set their log probs to 0
and all other tokens to -inf
so that they are sampled at their corresponding index.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFLogitsProcessor
( )
Abstract base class for all logit processors that can be applied during generation.
__call__
( input_ids: Tensorscores: Tensorcur_len: int ) β tf.Tensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
tf.Tensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
tf.Tensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search.cur_len (
int
) β The current length of valid input sequence tokens. In the TF implementation, the input_idsβ sequence length is the maximum length generate can produce, and we need to know which of its tokens are valid.kwargs (
Dict[str, Any]
, optional) β Additional logits processor specific kwargs.
Returns
tf.Tensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
TF method for processing logits.
class transformers.TFLogitsProcessorList
( iterable = () )
This class can be used to create a list of TFLogitsProcessor to subsequently process a scores
input tensor. This class inherits from list and adds a specific call method to apply each TFLogitsProcessor to the inputs.
__call__
( input_ids: Tensorscores: Tensorcur_len: int**kwargs ) β tf.Tensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
tf.Tensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
tf.Tensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search.cur_len (
int
) β The current length of valid input sequence tokens. In the TF implementation, the input_idsβ sequence length is the maximum length generate can produce, and we need to know which of its tokens are valid.kwargs (
Dict[str, Any]
, optional) β Additional logits processor specific kwargs.
Returns
tf.Tensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.TFLogitsWarper
( )
Abstract base class for all logit warpers that can be applied during generation with multinomial sampling.
__call__
( input_ids: Tensorscores: Tensorcur_len: int ) β tf.Tensor
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
tf.Tensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
tf.Tensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam search.cur_len (
int
) β The current length of valid input sequence tokens. In the TF implementation, the input_idsβ sequence length is the maximum length generate can produce, and we need to know which of its tokens are valid.kwargs (
Dict[str, Any]
, optional) β Additional logits processor specific kwargs.
Returns
tf.Tensor
of shape (batch_size, config.vocab_size)
The processed prediction scores.
TF method for warping logits.
class transformers.TFMinLengthLogitsProcessor
( min_length: inteos_token_id: int )
Parameters
min_length (
int
) β The minimum length below which the score ofeos_token_id
is set to-float("Inf")
.eos_token_id (
int
) β The id of the end-of-sequence token.
TFLogitsProcessor enforcing a min-length by setting EOS probability to 0.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFNoBadWordsLogitsProcessor
( bad_words_ids: typing.List[typing.List[int]]eos_token_id: int )
Parameters
bad_words_ids (
List[List[int]]
) β List of list of token ids that are not allowed to be generated. In order to get the tokens of the words that should not appear in the generated text, make sure to setadd_prefix_space=True
when initializing the tokenizer, and usetokenizer(bad_words, add_special_tokens=False).input_ids
. Theadd_prefix_space
argument is only supported for some slow tokenizers, as fast tokenizersβ prefixing behaviours come frompre tokenizers
. Read more here.eos_token_id (
int
) β The id of the end-of-sequence token.
TFLogitsProcessor that enforces that specified sequences will never be sampled.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFNoRepeatNGramLogitsProcessor
( ngram_size: int )
Parameters
ngram_size (
int
) β All ngrams of sizengram_size
can only occur once.
TFLogitsProcessor that enforces no repetition of n-grams. See Fairseq.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFRepetitionPenaltyLogitsProcessor
( penalty: float )
Parameters
repetition_penalty (
float
) β The parameter for repetition penalty. 1.0 means no penalty. See this paper for more details.
TFLogitsProcessor enforcing an exponential penalty on repeated sequences.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFSuppressTokensAtBeginLogitsProcessor
( begin_suppress_tokensbegin_index )
TFSuppressTokensAtBeginLogitsProcessor suppresses a list of tokens as soon as the generate
function starts generating using begin_index
tokens. This should ensure that the tokens defined by begin_suppress_tokens
at not sampled at the begining of the generation.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFSuppressTokensLogitsProcessor
( suppress_tokens )
This processor can be used to suppress a list of tokens. The processor will set their log probs to -inf
so that they are not sampled.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFTemperatureLogitsWarper
( temperature: float )
Parameters
temperature (
float
) β The value used to module the logits distribution.
TFLogitsWarper for temperature (exponential scaling output probability distribution).
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFTopKLogitsWarper
( top_k: intfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
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.
TFLogitsWarper that performs top-k, i.e. restricting to the k highest probability elements.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
class transformers.TFTopPLogitsWarper
( top_p: floatfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
top_p (
float
) β If set to < 1, only the smallest set of most probable tokens with probabilities that add up totop_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.
TFLogitsWarper that performs top-p, i.e. restricting to top tokens summing to <= prob_cut_off.
__call__
( input_ids: Tensorscores: Tensorcur_len: int )
FLAX
class transformers.FlaxForcedBOSTokenLogitsProcessor
( bos_token_id: int )
Parameters
bos_token_id (
int
) β The id of the token to force as the first generated token.
FlaxLogitsProcessor that enforces the specified token as the first generated token.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxForcedEOSTokenLogitsProcessor
( max_length: inteos_token_id: int )
Parameters
max_length (
int
) β The maximum length of the sequence to be generated.eos_token_id (
int
) β The id of the token to force as the last generated token whenmax_length
is reached.
FlaxLogitsProcessor that enforces the specified token as the last generated token when max_length
is reached.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxForceTokensLogitsProcessor
( force_token_map )
Parameters
force_token_map (
list
) β Map giving token ids and indices where they will be forced to be sampled.
FlaxLogitsProcessor that takes a list of pairs of integers which indicates a mapping from generation indices to token indices that will be forced before sampling. The processor will set their log probs to 0 and all other tokens to -inf
so that they are sampled at their corresponding index.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxLogitsProcessor
( )
Abstract base class for all logit processors that can be applied during generation.
__call__
( input_ids: Arrayscores: Array ) β jnp.ndarray
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
jnp.ndarray
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
jnp.ndarray
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam searchkwargs (
Dict[str, Any]
, optional) β Additional logits processor specific kwargs.
Returns
jnp.ndarray
of shape (batch_size, config.vocab_size)
The processed prediction scores.
Flax method for processing logits.
class transformers.FlaxLogitsProcessorList
( iterable = () )
This class can be used to create a list of FlaxLogitsProcessor or FlaxLogitsWarper to subsequently process a scores
input tensor. This class inherits from list and adds a specific call method to apply each FlaxLogitsProcessor or FlaxLogitsWarper to the inputs.
__call__
( input_ids: Arrayscores: Arraycur_len: int**kwargs ) β jnp.ndarray
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
jnp.ndarray
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
jnp.ndarray
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam searchkwargs (
Dict[str, Any]
, optional) β Additional logits processor specific kwargs.
Returns
jnp.ndarray
of shape (batch_size, config.vocab_size)
The processed prediction scores.
class transformers.FlaxLogitsWarper
( )
Abstract base class for all logit warpers that can be applied during generation with multinomial sampling.
__call__
( input_ids: Arrayscores: Array ) β jnp.ndarray
of shape (batch_size, config.vocab_size)
Parameters
input_ids (
jnp.ndarray
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
jnp.ndarray
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam search or log softmax for each vocabulary token when using beam searchkwargs (
Dict[str, Any]
, optional) β Additional logits processor specific kwargs.
Returns
jnp.ndarray
of shape (batch_size, config.vocab_size)
The processed prediction scores.
Flax method for warping logits.
class transformers.FlaxMinLengthLogitsProcessor
( min_length: inteos_token_id: int )
Parameters
min_length (
int
) β The minimum length below which the score ofeos_token_id
is set to-float("Inf")
.eos_token_id (
int
) β The id of the end-of-sequence token.
FlaxLogitsProcessor enforcing a min-length by setting EOS probability to 0.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxSuppressTokensAtBeginLogitsProcessor
( begin_suppress_tokensbegin_index )
Parameters
begin_suppress_tokens (
List[int]
) β Tokens to not sample.begin_index (
int
) β Index where the tokens are suppressed.
FlaxLogitsProcessor supressing a list of tokens as soon as the generate
function starts generating using begin_index
tokens. This should ensure that the tokens defined by begin_suppress_tokens
are not sampled at the begining of the generation.
__call__
( input_idsscorescur_len: int )
class transformers.FlaxSuppressTokensLogitsProcessor
( suppress_tokens: list )
Parameters
suppress_tokens (
list
) β Tokens to not sample.
FlaxLogitsProcessor suppressing a list of tokens at each decoding step. The processor will set their log probs to be -inf
so they are not sampled.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxTemperatureLogitsWarper
( temperature: float )
Parameters
temperature (
float
) β The value used to module the logits distribution.
FlaxLogitsWarper for temperature (exponential scaling output probability distribution).
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxTopKLogitsWarper
( top_k: intfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
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.
FlaxLogitsWarper that performs top-k, i.e. restricting to the k highest probability elements.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxTopPLogitsWarper
( top_p: floatfilter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
top_p (
float
) β If set to < 1, only the smallest set of most probable tokens with probabilities that add up totop_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.
FlaxLogitsWarper that performs top-p, i.e. restricting to top tokens summing to prob_cut_off <= prob_cut_off.
__call__
( input_ids: Arrayscores: Arraycur_len: int )
class transformers.FlaxWhisperTimeStampLogitsProcessor
( generate_configmodel_configdecoder_input_length )
Parameters
generate_config (
GenerateConfig
) β The generate config used to generate the output. The following parameters are required: eos_token_id (int
, optional, defaults to 50257): The id of the end-of-sequence token. no_timestamps_token_id (int
, optional, defaults to 50363): The id of the"<|notimestamps|>"
token. max_initial_timestamp_index (int
, optional, defaults to 1): Used to set the maximum value of the initial timestamp. This is used to prevent the model from predicting timestamps that are too far in the future.
Whisper specific Processor. This processor can be used to force a list of tokens. The processor will set their log probs to inf
so that they are sampled at their corresponding index.
__call__
( input_idsscorescur_len )
StoppingCriteria
A StoppingCriteria can be used to change when to stop generation (other than EOS token). Please note that this is exclusivelly available to our PyTorch implementations.
class transformers.StoppingCriteria
( )
Abstract base class for all stopping criteria that can be applied during generation.
__call__
( input_ids: LongTensorscores: FloatTensor**kwargs )
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax or scores for each vocabulary token after SoftMax.kwargs (
Dict[str, Any]
, optional) β Additional stopping criteria specific kwargs.
class transformers.StoppingCriteriaList
( iterable = () )
__call__
( input_ids: LongTensorscores: FloatTensor**kwargs )
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax or scores for each vocabulary token after SoftMax.kwargs (
Dict[str, Any]
, optional) β Additional stopping criteria specific kwargs.
class transformers.MaxLengthCriteria
( max_length: intmax_position_embeddings: typing.Optional[int] = None )
Parameters
max_length (
int
) β The maximum length that the output sequence can have in number of tokens.max_position_embeddings (
int
,optional
) β The maximum model length, as defined by the modelβsconfig.max_position_embeddings
attribute.
This class can be used to stop generation whenever the full generated number of tokens exceeds max_length
. Keep in mind for decoder-only type of transformers, this will include the initial prompted tokens.
__call__
( input_ids: LongTensorscores: FloatTensor**kwargs )
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax or scores for each vocabulary token after SoftMax.kwargs (
Dict[str, Any]
, optional) β Additional stopping criteria specific kwargs.
class transformers.MaxTimeCriteria
( max_time: floatinitial_timestamp: typing.Optional[float] = None )
Parameters
max_time (
float
) β The maximum allowed time in seconds for the generation.initial_time (
float
, optional, defaults totime.time()
) β The start of the generation allowed time.
This class can be used to stop generation whenever the full generation exceeds some amount of time. By default, the time will start being counted when you initialize this function. You can override this by passing an initial_time
.
__call__
( input_ids: LongTensorscores: FloatTensor**kwargs )
Parameters
input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
scores (
torch.FloatTensor
of shape(batch_size, config.vocab_size)
) β Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax or scores for each vocabulary token after SoftMax.kwargs (
Dict[str, Any]
, optional) β Additional stopping criteria specific kwargs.
Constraints
A Constraint can be used to force the generation to include specific tokens or sequences in the output. Please note that this is exclusivelly available to our PyTorch implementations.
class transformers.Constraint
( )
Abstract base class for all constraints that can be applied during generation. It must define how the constraint can be satisfied.
All classes that inherit Constraint must follow the requirement that
Copied
will always terminate (halt).
advance
( ) β token_ids(torch.tensor
)
Returns
token_ids(torch.tensor
)
Must be a tensor of a list of indexable tokens, not some integer.
When called, returns the token that would take this constraint one step closer to being fulfilled.
copy
( stateful = False ) β constraint(Constraint
)
Returns
constraint(Constraint
)
The same constraint as the one being called from.
Creates a new instance of this constraint.
does_advance
( token_id: int )
Reads in a token and returns whether it creates progress.
remaining
( )
Returns the number of remaining steps of advance()
in order to complete this constraint.
reset
( )
Resets the state of this constraint to its initialization. We would call this in cases where the fulfillment of a constraint is abrupted by an unwanted token.
test
( )
Tests whether this constraint has been properly defined.
update
( token_id: int ) β stepped(bool
)
Returns
stepped(bool
)
Whether this constraint has become one step closer to being fulfuilled. completed(bool
): Whether this constraint has been completely fulfilled by this token being generated. reset (bool
): Whether this constraint has reset its progress by this token being generated.
Reads in a token and returns booleans that indicate the progress made by it. This function will update the state of this object unlikes does_advance(self, token_id: int)
.
This isnβt to test whether a certain token will advance the progress; itβs to update its state as if it has been generated. This becomes important if token_id != desired token (refer to else statement in PhrasalConstraint)
class transformers.PhrasalConstraint
( token_ids: typing.List[int] )
Parameters
token_ids (
List[int]
) β The id of the token that must be generated by the output.
Constraint enforcing that an ordered sequence of tokens is included in the output.
class transformers.DisjunctiveConstraint
( nested_token_ids: typing.List[typing.List[int]] )
Parameters
nested_token_ids (
List[List[int]]
) β a list of words, where each word is a list of ids. This constraintis fulfilled by generating just one from the list of words. β
A special Constraint that is fulfilled by fulfilling just one of several constraints.
class transformers.ConstraintListState
( constraints: typing.List[transformers.generation.beam_constraints.Constraint] )
Parameters
constraints (
List[Constraint]
) β A list of Constraint objects that must be fulfilled by the beam scorer.
A class for beam scorers to track its progress through a list of constraints.
advance
( )
The list of tokens to generate such that we can make progress. By βlistβ we donβt mean the list of token that will fully fulfill a constraint.
Given constraints c_i = {t_ij | j == # of tokens}
, If weβre not in the middle of progressing through a specific constraint c_i
, we return:
[t_k1 for k in indices of unfulfilled constraints]
If we are in the middle of a constraint, then we return: [t_ij]
, where i
is the index of the inprogress constraint, j
is the next step for the constraint.
Though we donβt care which constraint is fulfilled first, if we are in the progress of fulfilling a constraint, thatβs the only one weβll return.
reset
( token_ids: typing.Optional[typing.List[int]] )
token_ids: the tokens generated thus far to reset the state of the progress through constraints.
BeamSearch
class transformers.BeamScorer
( )
Abstract base class for all beam scorers that are used for beam_search() and beam_sample().
process
( input_ids: LongTensornext_scores: FloatTensornext_tokens: LongTensornext_indices: LongTensor**kwargs ) β UserDict
Parameters
input_ids (
torch.LongTensor
of shape(batch_size * num_beams, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using any class inheriting from PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
next_scores (
torch.FloatTensor
of shape(batch_size, 2 * num_beams)
) β Current scores of the top2 * num_beams
non-finished beam hypotheses.next_tokens (
torch.LongTensor
of shape(batch_size, 2 * num_beams)
) βinput_ids
of the tokens corresponding to the top2 * num_beams
non-finished beam hypotheses.next_indices (
torch.LongTensor
of shape(batch_size, 2 * num_beams)
) β Beam indices indicating to which beam hypothesis thenext_tokens
correspond.pad_token_id (
int
, optional) β The id of the padding token.eos_token_id (
Union[int, List[int]]
, optional) β The id of the end-of-sequence token. Optionally, use a list to set multiple end-of-sequence tokens.beam_indices (
torch.LongTensor
, optional) β Beam indices indicating to which beam hypothesis each token correspond.group_index (
int
, optional) β The index of the group of beams. Used with group_beam_search().
Returns
UserDict
A dictionary composed of the fields as defined above:
next_beam_scores (
torch.FloatTensor
of shape(batch_size * num_beams)
) β Updated scores of all non-finished beams.next_beam_tokens (
torch.FloatTensor
of shape(batch_size * num_beams)
) β Next tokens to be added to the non-finished beam_hypotheses.next_beam_indices (
torch.FloatTensor
of shape(batch_size * num_beams)
) β Beam indices indicating to which beam the next tokens shall be added.
finalize
( input_ids: LongTensornext_scores: FloatTensornext_tokens: LongTensornext_indices: LongTensormax_length: int**kwargs ) β torch.LongTensor
of shape (batch_size * num_return_sequences, sequence_length)
Parameters
input_ids (
torch.LongTensor
of shape(batch_size * num_beams, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using any class inheriting from PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
final_beam_scores (
torch.FloatTensor
of shape(batch_size * num_beams)
) β The final scores of all non-finished beams.final_beam_tokens (
torch.FloatTensor
of shape(batch_size * num_beams)
) β The last tokens to be added to the non-finished beam_hypotheses.final_beam_indices (
torch.FloatTensor
of shape(batch_size * num_beams)
) β The beam indices indicating to which beam thefinal_beam_tokens
shall be added.pad_token_id (
int
, optional) β The id of the padding token.eos_token_id (
Union[int, List[int]]
, optional) β The id of the end-of-sequence token. Optionally, use a list to set multiple end-of-sequence tokens.
Returns
torch.LongTensor
of shape (batch_size * num_return_sequences, sequence_length)
The generated sequences. The second dimension (sequence_length) is either equal to max_length
or shorter if all batches finished early due to the eos_token_id
.
class transformers.BeamSearchScorer
( batch_size: intnum_beams: intdevice: devicelength_penalty: typing.Optional[float] = 1.0do_early_stopping: typing.Union[str, bool, NoneType] = Falsenum_beam_hyps_to_keep: typing.Optional[int] = 1num_beam_groups: typing.Optional[int] = 1max_length: typing.Optional[int] = None )
Parameters
batch_size (
int
) β Batch Size ofinput_ids
for which standard beam search decoding is run in parallel.num_beams (
int
) β Number of beams for beam search.device (
torch.device
) β Defines the device type (e.g.,"cpu"
or"cuda"
) on which this instance ofBeamSearchScorer
will be allocated.length_penalty (
float
, optional, defaults to 1.0) β Exponential penalty to the length that is used with beam-based generation. It is applied as an exponent to the sequence length, which in turn is used to divide the score of the sequence. Since the score is the log likelihood of the sequence (i.e. negative),length_penalty
> 0.0 promotes longer sequences, whilelength_penalty
< 0.0 encourages shorter sequences.do_early_stopping (
bool
orstr
, optional, defaults toFalse
) β Controls the stopping condition for beam-based methods, like beam-search. It accepts the following values:True
, where the generation stops as soon as there arenum_beams
complete candidates;False
, where an heuristic is applied and the generation stops when is it very unlikely to find better candidates;"never"
, where the beam search procedure only stops when there cannot be better candidates (canonical beam search algorithm).num_beam_hyps_to_keep (
int
, optional, defaults to 1) β The number of beam hypotheses that shall be returned upon calling~transformer.BeamSearchScorer.finalize
.num_beam_groups (
int
) β Number of groups to dividenum_beams
into in order to ensure diversity among different groups of beams. See this paper for more details.max_length (
int
, optional) β The maximum length of the sequence to be generated.
BeamScorer implementing standard beam search decoding.
Adapted in part from Facebookβs XLM beam search code.
Reference for the diverse beam search algorithm and implementation Ashwin Kalyanβs DBS implementation
process
( input_ids: LongTensornext_scores: FloatTensornext_tokens: LongTensornext_indices: LongTensorpad_token_id: typing.Optional[int] = Noneeos_token_id: typing.Union[int, typing.List[int], NoneType] = Nonebeam_indices: typing.Optional[torch.LongTensor] = Nonegroup_index: typing.Optional[int] = 0 )
finalize
( input_ids: LongTensorfinal_beam_scores: FloatTensorfinal_beam_tokens: LongTensorfinal_beam_indices: LongTensormax_length: intpad_token_id: typing.Optional[int] = Noneeos_token_id: typing.Union[int, typing.List[int], NoneType] = Nonebeam_indices: typing.Optional[torch.LongTensor] = None )
class transformers.ConstrainedBeamSearchScorer
( batch_size: intnum_beams: intconstraints: typing.List[transformers.generation.beam_constraints.Constraint]device: devicelength_penalty: typing.Optional[float] = 1.0do_early_stopping: typing.Union[str, bool, NoneType] = Falsenum_beam_hyps_to_keep: typing.Optional[int] = 1num_beam_groups: typing.Optional[int] = 1max_length: typing.Optional[int] = None )
Parameters
batch_size (
int
) β Batch Size ofinput_ids
for which standard beam search decoding is run in parallel.num_beams (
int
) β Number of beams for beam search.constraints (
List[Constraint]
) β A list of positive constraints represented asConstraint
objects that must be fulfilled in the generation output. For more information, the documentation of Constraint should be read.device (
torch.device
) β Defines the device type (e.g.,"cpu"
or"cuda"
) on which this instance ofBeamSearchScorer
will be allocated.length_penalty (
float
, optional, defaults to 1.0) β Exponential penalty to the length that is used with beam-based generation. It is applied as an exponent to the sequence length, which in turn is used to divide the score of the sequence. Since the score is the log likelihood of the sequence (i.e. negative),length_penalty
> 0.0 promotes longer sequences, whilelength_penalty
< 0.0 encourages shorter sequences.do_early_stopping (
bool
orstr
, optional, defaults toFalse
) β Controls the stopping condition for beam-based methods, like beam-search. It accepts the following values:True
, where the generation stops as soon as there arenum_beams
complete candidates;False
, where an heuristic is applied and the generation stops when is it very unlikely to find better candidates;"never"
, where the beam search procedure only stops when there cannot be better candidates (canonical beam search algorithm).num_beam_hyps_to_keep (
int
, optional, defaults to 1) β The number of beam hypotheses that shall be returned upon calling~transformer.BeamSearchScorer.finalize
.num_beam_groups (
int
) β Number of groups to dividenum_beams
into in order to ensure diversity among different groups of beams. See this paper for more details.max_length (
int
, optional) β The maximum length of the sequence to be generated.
BeamScorer implementing constrained beam search decoding.
process
( input_ids: LongTensornext_scores: FloatTensornext_tokens: LongTensornext_indices: LongTensorscores_for_all_vocab: FloatTensorpad_token_id: typing.Optional[int] = Noneeos_token_id: typing.Union[int, typing.List[int], NoneType] = Nonebeam_indices: typing.Optional[torch.LongTensor] = None ) β UserDict
Parameters
input_ids (
torch.LongTensor
of shape(batch_size * num_beams, sequence_length)
) β Indices of input sequence tokens in the vocabulary.Indices can be obtained using any class inheriting from PreTrainedTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call() for details.
next_scores (
torch.FloatTensor
of shape(batch_size, 2 * num_beams)
) β Current scores of the top2 * num_beams
non-finished beam hypotheses.next_tokens (
torch.LongTensor
of shape(batch_size, 2 * num_beams)
) βinput_ids
of the tokens corresponding to the top2 * num_beams
non-finished beam hypotheses.next_indices (
torch.LongTensor
of shape(batch_size, 2 * num_beams)
) β Beam indices indicating to which beam hypothesis thenext_tokens
correspond.scores_for_all_vocab (
torch.FloatTensor
of shape(batch_size * num_beams, sequence_length)
) β The scores of all tokens in the vocabulary for each of the beam hypotheses.pad_token_id (
int
, optional) β The id of the padding token.eos_token_id (
Union[int, List[int]]
, optional) β The id of the end-of-sequence token. Optionally, use a list to set multiple end-of-sequence tokens.beam_indices (
torch.LongTensor
, optional) β Beam indices indicating to which beam hypothesis each token correspond.
Returns
UserDict
A dictionary composed of the fields as defined above:
next_beam_scores (
torch.FloatTensor
of shape(batch_size * num_beams)
) β Updated scores of all non-finished beams.next_beam_tokens (
torch.FloatTensor
of shape(batch_size * num_beams)
) β Next tokens to be added to the non-finished beam_hypotheses.next_beam_indices (
torch.FloatTensor
of shape(batch_size * num_beams)
) β Beam indices indicating to which beam the next tokens shall be added.
finalize
( input_ids: LongTensorfinal_beam_scores: FloatTensorfinal_beam_tokens: LongTensorfinal_beam_indices: LongTensormax_length: intpad_token_id: typing.Optional[int] = Noneeos_token_id: typing.Union[int, typing.List[int], NoneType] = Nonebeam_indices: typing.Optional[torch.LongTensor] = None )
Utilities
transformers.top_k_top_p_filtering
( logits: FloatTensortop_k: int = 0top_p: float = 1.0filter_value: float = -infmin_tokens_to_keep: int = 1 )
Parameters
top_k (
int
, optional, defaults to 0) β If > 0, only keep the top k tokens with highest probability (top-k filtering)top_p (
float
, optional, defaults to 1.0) β If < 1.0, only keep the top tokens with cumulative probability >= top_p (nucleus filtering). Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)min_tokens_to_keep (
int
, optional, defaults to 1) β Minimumber of tokens we keep per batch example in the output.
Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
transformers.tf_top_k_top_p_filtering
( logitstop_k = 0top_p = 1.0filter_value = -infmin_tokens_to_keep = 1 )
Parameters
top_k (
int
, optional, defaults to 0) β If > 0, only keep the top k tokens with highest probability (top-k filtering)top_p (
float
, optional, defaults to 1.0) β If < 1.0, only keep the top tokens with cumulative probability >= top_p (nucleus filtering). Nucleus filtering is described in Holtzman et al. (http://arxiv.org/abs/1904.09751)min_tokens_to_keep (
int
, optional, defaults to 1) β Minimumber of tokens we keep per batch example in the output.
Filter a distribution of logits using top-k and/or nucleus (top-p) filtering
From: https://gist.github.com/thomwolf/1a5a29f6962089e871b94cbd09daf317
Streamers
class transformers.TextStreamer
( tokenizer: AutoTokenizerskip_prompt: bool = False**decode_kwargs )
Parameters
tokenizer (
AutoTokenizer
) β The tokenized used to decode the tokens.skip_prompt (
bool
, optional, defaults toFalse
) β Whether to skip the prompt to.generate()
or not. Useful e.g. for chatbots.decode_kwargs (
dict
, optional) β Additional keyword arguments to pass to the tokenizerβsdecode
method.
Simple text streamer that prints the token(s) to stdout as soon as entire words are formed.
The API for the streamer classes is still under development and may change in the future.
Examples:
Copied
end
( )
Flushes any remaining cache and prints a newline to stdout.
on_finalized_text
( text: strstream_end: bool = False )
Prints the new text to stdout. If the stream is ending, also prints a newline.
put
( value )
Receives tokens, decodes them, and prints them to stdout as soon as they form entire words.
class transformers.TextIteratorStreamer
( tokenizer: AutoTokenizerskip_prompt: bool = Falsetimeout: typing.Optional[float] = None**decode_kwargs )
Parameters
tokenizer (
AutoTokenizer
) β The tokenized used to decode the tokens.skip_prompt (
bool
, optional, defaults toFalse
) β Whether to skip the prompt to.generate()
or not. Useful e.g. for chatbots.timeout (
float
, optional) β The timeout for the text queue. IfNone
, the queue will block indefinitely. Useful to handle exceptions in.generate()
, when it is called in a separate thread.decode_kwargs (
dict
, optional) β Additional keyword arguments to pass to the tokenizerβsdecode
method.
Streamer that stores print-ready text in a queue, to be used by a downstream application as an iterator. This is useful for applications that benefit from acessing the generated text in a non-blocking way (e.g. in an interactive Gradio demo).
The API for the streamer classes is still under development and may change in the future.
Examples:
Copied
on_finalized_text
( text: strstream_end: bool = False )
Put the new text in the queue. If the stream is ending, also put a stop signal in the queue.
Last updated