# Utilidades para la generación Esta página enumera todas las funciones de utilidad utilizadas por [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate). ## Generar salidas[[transformers.generation.GenerateDecoderOnlyOutput]] La salida de [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate) es una instancia de una subclase de [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput). Esta salida es una estructura de datos que contiene toda la información devuelta por [generate()](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationMixin.generate), pero también puede usarse como tupla o diccionario. Aquí hay un ejemplo: ```python from transformers import GPT2Tokenizer, GPT2LMHeadModel tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2") model = GPT2LMHeadModel.from_pretrained("openai-community/gpt2") inputs = tokenizer("Hello, my dog is cute and ", return_tensors="pt") generation_output = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) ``` El objeto `generation_output` es un [GenerateDecoderOnlyOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput); como podemos ver en la documentación de esa clase a continuación, significa que tiene los siguientes atributos: - `sequences`: las secuencias de tokens generadas - `scores` (opcional): las puntuaciones de predicción de la cabeza de modelado de lenguaje, para cada paso de generación - `hidden_states` (opcional): los estados ocultos del modelo, para cada paso de generación - `attentions` (opcional): los pesos de atención del modelo, para cada paso de generación Aquí tenemos las `scores` porque pasamos `output_scores=True`, pero no tenemos `hidden_states` ni `attentions` porque no pasamos `output_hidden_states=True` ni `output_attentions=True`. Puede acceder a cada atributo de la forma habitual, y si ese atributo no ha sido devuelto por el modelo, obtendrá `None`. Por ejemplo, `generation_output.scores` son todas las puntuaciones de predicción generadas por la cabeza de modelado de lenguaje, y `generation_output.attentions` es `None`. Al usar nuestro objeto `generation_output` como una tupla, solo conserva los atributos que no tienen valores `None`. Aquí, por ejemplo, tiene dos elementos, `loss` y luego `logits`, por lo que ```python generation_output[:2] ``` devolverá, por ejemplo, la tupla `(generation_output.sequences, generation_output.scores)`. Al usar nuestro objeto `generation_output` como un diccionario, solo conserva los atributos que no tienen valores `None`. Aquí, por ejemplo, tiene dos claves: `sequences` y `scores`. Aquí documentamos todos los tipos de salida. #### transformers.generation.GenerateDecoderOnlyOutput[[transformers.generation.GenerateDecoderOnlyOutput]] ```python transformers.generation.GenerateDecoderOnlyOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L183) **Parámetros:** sequences (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Las secuencias generadas. La segunda dimensión (sequence_length) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`. scores (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_scores=True`) : Puntuaciones de predicción procesadas de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax) en cada paso de generación. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento para cada token generado), con cada tensor de forma `(batch_size, config.vocab_size)`. logits (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_logits=True`) : Puntuaciones de predicción sin procesar de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax) en cada paso de generación. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento para cada token generado), con cada tensor de forma `(batch_size, config.vocab_size)`. attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size, num_heads, generated_length, sequence_length)`. hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, devuelto cuando `output_hidden_states=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size, generated_length, hidden_size)`. past_key_values (`Cache`, *opcional*, se devuelve cuando `use_cache=True`) : Devuelve la caché del modelo, utilizada para acelerar la decodificación. Los distintos modelos tienen un formato de caché diferente; consulte la documentación del modelo. Por lo general, es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Salidas de modelos de generación solo decodificador, al utilizar métodos no de haz. #### transformers.generation.GenerateEncoderDecoderOutput[[transformers.generation.GenerateEncoderDecoderOutput]] ```python transformers.generation.GenerateEncoderDecoderOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L219) **Parámetros:** sequences (`torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`) : Las secuencias generadas. La segunda dimensión (sequence_length) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`. scores (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_scores=True`) : Puntuaciones de predicción procesadas de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax) en cada paso de generación. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento para cada token generado), con cada tensor de forma `(batch_size, config.vocab_size)`. logits (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_logits=True`) : Puntuaciones de predicción sin procesar de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax) en cada paso de generación. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento para cada token generado), con cada tensor de forma `(batch_size, config.vocab_size)`. encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa del decodificador) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, devuelto cuando `output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings + uno para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. decoder_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size, num_heads, generated_length, sequence_length)`. cross_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size, num_heads, generated_length, sequence_length)`. decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, devuelto cuando `output_hidden_states=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size, generated_length, hidden_size)`. past_key_values (`Cache`, *opcional*, se devuelve cuando `use_cache=True`) : Devuelve la caché del modelo, utilizada para acelerar la decodificación. Los distintos modelos tienen un formato de caché diferente; consulte la documentación del modelo. Por lo general, es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Salidas de los modelos de generación encoder-decoder al utilizar métodos que no son de haz. #### transformers.generation.GenerateBeamDecoderOnlyOutput[[transformers.generation.GenerateBeamDecoderOnlyOutput]] ```python transformers.generation.GenerateBeamDecoderOnlyOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L267) **Parámetros:** sequences (`torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`) : Las secuencias generadas. La segunda dimensión (sequence_length) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`. sequences_scores (`torch.Tensor` de forma `(batch_size*num_return_sequences)`, *opcional*, devuelto cuando `output_scores=True`) : Puntuaciones finales de los haces de las `sequences` generadas. scores (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_scores=True`) : Puntuaciones de transición de beam para cada token del vocabulario en cada paso de generación. Las puntuaciones de transición de beam consisten en las probabilidades logarítmicas de los tokens condicionadas al log softmax de los tokens generados previamente en este beam. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento por cada token generado), donde cada tensor tiene la forma `(batch_size*num_beams, config.vocab_size)`. logits (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_logits=True`) : Puntuaciones de predicción sin procesar de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax) en cada paso de generación. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento para cada token generado), con cada tensor de forma `(batch_size*num_beams, config.vocab_size)`. beam_indices (`torch.LongTensor`, *opcional*, se devuelve cuando `output_scores=True`) : Índices de haz del id del token generado en cada paso de generación. `torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`. attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size*num_beams, num_heads, generated_length, sequence_length)`. hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, devuelto cuando `output_hidden_states=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`. past_key_values (`Cache`, *opcional*, se devuelve cuando `use_cache=True`) : Devuelve la caché del modelo, utilizada para acelerar la decodificación. Los distintos modelos tienen un formato de caché diferente; consulte la documentación del modelo. Por lo general, es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Salidas de modelos de generación solo decodificador, al utilizar métodos de haz. #### transformers.generation.GenerateBeamEncoderDecoderOutput[[transformers.generation.GenerateBeamEncoderDecoderOutput]] ```python transformers.generation.GenerateBeamEncoderDecoderOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L311) **Parámetros:** sequences (`torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`) : Las secuencias generadas. La segunda dimensión (sequence_length) es igual a `max_length` o más corta si todos los lotes terminaron antes debido a `eos_token_id`. sequences_scores (`torch.Tensor` de forma `(batch_size*num_return_sequences)`, *opcional*, devuelto cuando `output_scores=True`) : Puntuaciones finales de los haces de las `sequences` generadas. scores (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_scores=True`) : Puntuaciones de transición de beam para cada token del vocabulario en cada paso de generación. Las puntuaciones de transición de beam consisten en las probabilidades logarítmicas de los tokens condicionadas al log softmax de los tokens generados previamente en este beam. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento por cada token generado), donde cada tensor tiene la forma `(batch_size*num_beams, config.vocab_size)`. logits (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_logits=True`) : Puntuaciones de predicción sin procesar de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax) en cada paso de generación. Tupla de `torch.Tensor` con hasta `max_new_tokens` elementos (un elemento para cada token generado), con cada tensor de forma `(batch_size*num_beams, config.vocab_size)`. beam_indices (`torch.LongTensor`, *opcional*, se devuelve cuando `output_scores=True`) : Índices de haz del id del token generado en cada paso de generación. `torch.LongTensor` de forma `(batch_size*num_return_sequences, sequence_length)`. encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa del decodificador) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. encoder_hidden_states (`tuple(torch.Tensor)`, *opcional*, devuelto cuando `output_hidden_states=True`) : Tupla de `torch.Tensor` (uno para la salida de los embeddings + uno para la salida de cada capa) de forma `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`. decoder_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`. cross_attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size, num_heads, generated_length, sequence_length)`. decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, devuelto cuando `output_hidden_states=True`) : Tupla (un elemento para cada token generado) de tuplas (un elemento para cada capa del decodificador) de `torch.Tensor` de forma `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`. past_key_values (`Cache`, *opcional*, se devuelve cuando `use_cache=True`) : Devuelve la caché del modelo, utilizada para acelerar la decodificación. Los distintos modelos tienen un formato de caché diferente; consulte la documentación del modelo. Por lo general, es una instancia de [Cache](/docs/transformers/main/es/internal/generation_utils#transformers.Cache). Salidas de los modelos de generación encoder-decoder, al utilizar métodos de haz. ## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]] Un [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) se puede utilizar para modificar las puntuaciones de predicción de la cabeza de un modelo de lenguaje para la generación. #### transformers.AlternatingCodebooksLogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]] ```python transformers.AlternatingCodebooksLogitsProcessor(input_start_len: int, semantic_vocab_size: int, codebook_size: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2222) **Parámetros:** input_start_len (`int`) : La longitud de la secuencia de entrada inicial. semantic_vocab_size (`int`) : Tamaño del vocabulario de la parte semántica, es decir, el número de tokens asociados al vocabulario semántico. codebook_size (`int`) : Número de tokens asociados al codebook. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que aplica una generación alternada entre los dos libros de códigos de Bark. Este procesador de logits es compatible exclusivamente con el submodelo fino de [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark). Consulte la documentación del modelo para ver ejemplos. #### __llamada__[[transformers.AlternatingCodebooksLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2251) #### transformers.ClassifierFreeGuidanceLogitsProcessor[[transformers.ClassifierFreeGuidanceLogitsProcessor]] ```python transformers.ClassifierFreeGuidanceLogitsProcessor(guidance_scale) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2158) **Parámetros:** guidance_scale (float) : La escala de orientación para la orientación libre de clasificador (CFG). CFG se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta anima al modelo a generar muestras más estrechamente vinculadas al prompt de entrada, generalmente a costa de una menor calidad. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) para la guía libre de clasificador (CFG). Las puntuaciones se dividen a lo largo de la dimensión del lote, donde la primera mitad corresponde a los logits condicionales (predichos a partir del prompt de entrada) y la segunda mitad corresponde a los logits incondicionales (predichos a partir de un prompt vacío o 'null'). El procesador calcula una media ponderada entre los logits condicionales e incondicionales, parametrizada por `guidance_scale`. Consulte [el artículo](https://huggingface.co/papers/2306.05284) para obtener más información. Este procesador de logits es compatible exclusivamente con [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen) Ejemplos: ```python >>> from transformers import AutoProcessor, MusicgenForConditionalGeneration >>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small") >>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small") >>> inputs = processor( ... text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"], ... padding=True, ... return_tensors="pt", ... ) >>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256) ``` #### __llamada__[[transformers.ClassifierFreeGuidanceLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2206) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.EncoderNoRepeatNGramLogitsProcessor[[transformers.EncoderNoRepeatNGramLogitsProcessor]] ```python transformers.EncoderNoRepeatNGramLogitsProcessor(encoder_ngram_size: int, encoder_input_ids: LongTensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1173) **Parámetros:** encoder_ngram_size (`int`) : Todos los ngramas de tamaño `ngram_size` solo pueden aparecer dentro de los ids de entrada del codificador. encoder_input_ids (`int`) : Los encoder_input_ids que no deben repetirse dentro de los ids del decodificador. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que funciona de manera similar a [NoRepeatNGramLogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor), pero aplicado exclusivamente para evitar la repetición de n-gramas presentes en el prompt. Está diseñado para fomentar la conversación en un modelo de lenguaje, evitando la generación de n-gramas presentes en rondas anteriores de la conversación. Ejemplos: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("Alice: I love cats. What do you love?\nBob:", return_tensors="pt") >>> # With greedy decoding, we see Bob repeating Alice's opinion. If Bob was a chatbot, it would be a poor one. >>> outputs = model.generate(**inputs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice: I love cats. What do you love? Bob: I love cats. What do you >>> # With this logits processor, we can prevent Bob from repeating Alice's opinion. >>> outputs = model.generate(**inputs, encoder_no_repeat_ngram_size=2) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice: I love cats. What do you love? Bob: My cats are very cute. ``` #### __llamada__[[transformers.EncoderNoRepeatNGramLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1222) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.EncoderRepetitionPenaltyLogitsProcessor[[transformers.EncoderRepetitionPenaltyLogitsProcessor]] ```python transformers.EncoderRepetitionPenaltyLogitsProcessor(penalty: float, encoder_input_ids: LongTensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L440) **Parámetros:** penalty (`float`) : El parámetro para la penalización de repetición. 1.0 significa sin penalización. Valores superiores a 1.0 premian los tokens del prompt. Valores entre 0.0 y 1.0 penalizan los tokens del prompt. encoder_input_ids (`torch.LongTensor`) : Los encoder_input_ids que deben repetirse dentro de los ids del decodificador. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que funciona de manera similar a [RepetitionPenaltyLogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor), pero con una penalización *inversa* que se aplica a los tokens presentes en el prompt. En otras palabras, una penalización superior a 1.0 aumenta la probabilidad de seleccionar tokens que estaban presentes en el prompt. Está diseñado para evitar la alucinación en tareas basadas en la entrada, como la resumición. Aunque originalmente estaba pensado para modelos codificador-decodificador, también se puede utilizar con modelos solo de decodificador, como los LLM. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer(["Alice and Bob. The third member's name was"], return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) Alice and Bob. The third member's name was not mentioned. >>> # With the `encoder_repetition_penalty` argument we can trigger this logits processor in `generate`, which can >>> # promote the use of prompt tokens ("Bob" in this example) >>> gen_out = model.generate(**inputs, encoder_repetition_penalty=1.2) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) Alice and Bob. The third member's name was Bob. The third member's name was Bob. ``` #### __llamada__[[transformers.EncoderRepetitionPenaltyLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L486) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.EpsilonLogitsWarper[[transformers.EpsilonLogitsWarper]] ```python transformers.EpsilonLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L897) **Parámetros:** epsilon (`float`) : Si se establece en un valor > 0, solo se conservan para la generación los tokens con probabilidades `epsilon` o superiores. filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores filtrados se establecerán en este valor float. min_tokens_to_keep (`int`, *opcional*, valor predeterminado 1) : Número mínimo de tokens que no se pueden filtrar. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que realiza muestreo por epsilon, es decir, restringe a los tokens con `prob >= epsilon`. Toma los tokens min_tokens_to_keep más grandes si ningún token satisface esta restricción. Consulte [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) para obtener más información. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With epsilon sampling, the output gets restricted to high-probability tokens. Note that this is similar to >>> # Top P sampling, which restricts tokens based on their cumulative probability. >>> # Pro tip: The paper recommends using `epsilon_cutoff` values between 3e-4 and 9e-4 >>> outputs = model.generate(**inputs, do_sample=True, epsilon_cutoff=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __llamada__[[transformers.EpsilonLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L952) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.EtaLogitsWarper[[transformers.EtaLogitsWarper]] ```python transformers.EtaLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1, device: str = 'cpu') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L966) **Parámetros:** epsilon (`float`) : Un valor flotante en el rango (0, 1). Hipervariable utilizada para calcular el valor de corte dinámico, `eta`. Los valores sugeridos en el artículo van desde 3e-4 hasta 4e-3, dependiendo del tamaño del modelo. filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores que se encuentran por debajo del valor de corte dinámico, `eta`, se establecen en este valor float. Este parámetro es útil cuando los logits deben modificarse para tokens con probabilidad muy baja que deben excluirse por completo de la generación. min_tokens_to_keep (`int`, *opcional*, valor predeterminado 1) : Especifica el número mínimo de tokens que deben conservarse para la generación, independientemente de sus probabilidades. Por ejemplo, si `min_tokens_to_keep` se establece en 1, siempre se conservará al menos un token para la generación, incluso si todos los tokens tienen probabilidades por debajo del umbral `eta`. device (`str`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo en el que se asignarán los tensores. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que realiza eta-sampling, una técnica para filtrar tokens con probabilidades por debajo de un valor de corte dinámico, `eta`, calculado a partir de una combinación del hiperparámetro `epsilon` y la entropía de las probabilidades de los tokens, es decir, `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. Si ningún token cumple esta restricción, se toman los min_tokens_to_keep tokens más grandes. Aborda el problema de la baja calidad en muestras largas de texto generadas por modelos de lenguaje neuronales, lo que conduce a un texto más coherente y fluido. Consulte [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) para obtener más información. Nota: `do_sample` debe estar establecido en `True` para que este `LogitsProcessor` funcione. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With eta sampling, the output gets restricted to high-probability tokens. You can see it as a dynamic form of >>> # epsilon sampling that adapts its cutoff probability based on the entropy (high entropy = lower cutoff). >>> # Pro tip: The paper recommends using `eta_cutoff` values between 3e-4 to 4e-3 >>> outputs = model.generate(**inputs, do_sample=True, eta_cutoff=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __llamada__[[transformers.EtaLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1035) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.ExponentialDecayLengthPenalty[[transformers.ExponentialDecayLengthPenalty]] ```python transformers.ExponentialDecayLengthPenalty(exponential_decay_length_penalty: tuple, eos_token_id: typing.Union[int, list[int], torch.Tensor], input_ids_seq_length: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1712) **Parámetros:** exponential_decay_length_penalty (`tuple(int, float)`) : Esta tupla debe constar de: `(start_index, decay_factor)`, donde `start_index` indica dónde comienza la penalización y `decay_factor` representa el factor de decaimiento exponencial eos_token_id (`Union[int, list[int], torch.Tensor]`) : El o los id del token *end-of-sequence*. input_ids_seq_length (`int`) : La longitud de la secuencia de entrada. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que aumenta exponencialmente la puntuación de `eos_token_id` una vez alcanzado `start_index`. Esto permite generar secuencias más cortas sin un corte fijo, de modo que `eos_token` pueda predecirse en una posición significativa. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> text = "Just wanted to let you know, I" >>> inputs = tokenizer(text, return_tensors="pt") >>> # Let's consider that we want short sentences, so we limit `max_length=30`. However, we observe that the answer >>> # tends to end abruptly. >>> set_seed(1) >>> outputs = model.generate(**inputs, do_sample=True, temperature=0.9, max_length=30, pad_token_id=50256) >>> print(tokenizer.batch_decode(outputs)[0]) Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was published in 2010. Although >>> # To promote the appearance of the EOS token at the right time, we add the `exponential_decay_length_penalty = >>> # (start_index, decay_factor)`. Instead of cutting at max_tokens, the output comes to an end before and usually >>> # with more meaning. What happens is that starting from `start_index` the EOS token score will be increased >>> # by `decay_factor` exponentially. However, if you set a high decay factor, you may also end up with abruptly >>> # ending sequences. >>> set_seed(1) >>> outputs = model.generate( ... **inputs, ... do_sample=True, ... temperature=0.9, ... max_length=30, ... pad_token_id=50256, ... exponential_decay_length_penalty=(15, 1.6), ... ) >>> print(tokenizer.batch_decode(outputs)[0]) Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which<|endoftext|> >>> # With a small decay factor, you will have a higher chance of getting a meaningful sequence. >>> set_seed(1) >>> outputs = model.generate( ... **inputs, ... do_sample=True, ... temperature=0.9, ... max_length=30, ... pad_token_id=50256, ... exponential_decay_length_penalty=(15, 1.01), ... ) >>> print(tokenizer.batch_decode(outputs)[0]) Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was published in 2010.<|endoftext|> ``` #### __llamada__[[transformers.ExponentialDecayLengthPenalty.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1798) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.ForcedBOSTokenLogitsProcessor[[transformers.ForcedBOSTokenLogitsProcessor]] ```python transformers.ForcedBOSTokenLogitsProcessor(bos_token_id: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1590) **Parámetros:** bos_token_id (`int`) : El id del token que se debe forzar como el primer token generado. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que fuerza el token especificado como el primer token generado. Se usa con modelos encoder-decoder. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM >>> model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small") >>> tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small") >>> inputs = tokenizer("Translate from English to German: I love cats.", return_tensors="pt") >>> # By default, it continues generating according to the model's logits >>> outputs = model.generate(**inputs, max_new_tokens=10) >>> print(tokenizer.batch_decode(outputs)[0]) Ich liebe Kitty. >>> # We can use `forced_bos_token_id` to force the start of generation with an encoder-decoder model >>> # (including forcing it to end straight away with an EOS token) >>> outputs = model.generate(**inputs, max_new_tokens=10, forced_bos_token_id=tokenizer.eos_token_id) >>> print(tokenizer.batch_decode(outputs)[0]) ``` #### __llamada__[[transformers.ForcedBOSTokenLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1625) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.ForcedEOSTokenLogitsProcessor[[transformers.ForcedEOSTokenLogitsProcessor]] ```python transformers.ForcedEOSTokenLogitsProcessor(max_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1635) **Parámetros:** max_length (`int`) : La longitud máxima de la secuencia que se generará. eos_token_id (`Union[int, list[int], torch.Tensor]`) : El o los id del token *end-of-sequence*. device (`str`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo en el que se asignarán los tensores. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que fuerza el token especificado como el último token generado cuando se alcanza `max_length`. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt") >>> # By default, it continues generating according to the model's logits >>> outputs = model.generate(**inputs, max_new_tokens=10) >>> print(tokenizer.batch_decode(outputs)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8 >>> # `forced_eos_token_id` ensures the generation ends with a EOS token >>> outputs = model.generate(**inputs, max_new_tokens=10, forced_eos_token_id=tokenizer.eos_token_id) >>> print(tokenizer.batch_decode(outputs)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7,<|endoftext|> ``` #### __llamada__[[transformers.ForcedEOSTokenLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1681) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.InfNanRemoveLogitsProcessor[[transformers.InfNanRemoveLogitsProcessor]] ```python transformers.InfNanRemoveLogitsProcessor() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1691) [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que elimina todos los valores `nan` y `inf` para evitar que el método de generación falle. Tenga en cuenta que el uso del procesador de logits solo debe emplearse si es necesario, ya que puede ralentizar el método de generación. Este procesador de logits no tiene un ejemplo de `generate`, ya que no debería existir una combinación correcta de banderas que justifique su uso. #### __llamada__[[transformers.InfNanRemoveLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1700) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.LogitNormalization[[transformers.LogitNormalization]] ```python transformers.LogitNormalization() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1814) [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) para normalizar las puntuaciones mediante log-softmax. Es importante normalizar las puntuaciones durante la búsqueda por haz, después de aplicar los procesadores o transformadores de logits, ya que el algoritmo de búsqueda utilizado en esta biblioteca no lo hace (solo lo hace antes, pero es posible que necesiten renormalización), aunque sigue suponiendo que las puntuaciones están normalizadas al comparar las hipótesis. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> import torch >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt") >>> # By default, the scores are not normalized -- the sum of their exponentials is NOT a normalized probability >>> # distribution, summing to 1 >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) >>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4)) False >>> # Normalizing them may have a positive impact on beam methods, or when using the scores on your application >>> outputs = model.generate(**inputs, renormalize_logits=True, return_dict_in_generate=True, output_scores=True) >>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4)) True ``` #### __llamada__[[transformers.LogitNormalization.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1845) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.LogitsProcessor[[transformers.LogitsProcessor]] ```python transformers.LogitsProcessor() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L49) Clase base abstracta para todos los procesadores de logits que pueden aplicarse durante la generación. #### __llamada__[[transformers.LogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L56) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.LogitsProcessorList[[transformers.LogitsProcessorList]] ```python transformers.LogitsProcessorList(iterable = ()) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L63) Esta clase se puede utilizar para crear una lista de [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) para procesar posteriormente un tensor de entrada `scores`. Esta clase hereda de list y añade un método *__call__* específico para aplicar cada [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) a las entradas. #### __llamada__[[transformers.LogitsProcessorList.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L70) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces kwargs (`dict[str, Any]`, *opcional*) : Argumentos adicionales específicos de un procesador de logits. **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.MinLengthLogitsProcessor[[transformers.MinLengthLogitsProcessor]] ```python transformers.MinLengthLogitsProcessor(min_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L101) **Parámetros:** min_length (`int`) : La longitud mínima por debajo de la cual la puntuación de `eos_token_id` se establece en `-float("Inf")`. eos_token_id (`Union[int, list[int], torch.Tensor]`) : El o los id del token *end-of-sequence*. device (`str`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo en el que se asignarán los tensores. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que aplica una longitud mínima estableciendo la probabilidad de EOS en 0. Ten en cuenta que, en los modelos solo decodificador como la mayoría de los LLM, la longitud incluye el prompt. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("A number:", return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one >>> # setting `min_length` to a value smaller than the uncontrolled output length has no impact >>> gen_out = model.generate(**inputs, min_length=3) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one >>> # setting a larger `min_length` will force the model to generate beyond its natural ending point, which is not >>> # necessarily incorrect >>> gen_out = model.generate(**inputs, min_length=10) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one thousand, nine hundred and ninety-four ``` #### __llamada__[[transformers.MinLengthLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L154) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.MinNewTokensLengthLogitsProcessor[[transformers.MinNewTokensLengthLogitsProcessor]] ```python transformers.MinNewTokensLengthLogitsProcessor(prompt_length_to_skip: int, min_new_tokens: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L164) **Parámetros:** prompt_length_to_skip (`int`) : La longitud de los tokens de entrada. No es un argumento válido cuando se usa con `generate`, ya que asignará automáticamente la longitud de entrada. min_new_tokens (`int`) : Longitud mínima de los *nuevos* tokens por debajo de la cual la puntuación de `eos_token_id` se establece en `-float("Inf")`. eos_token_id (`Union[int, list[int], torch.Tensor]`) : El o los id del token *end-of-sequence*. device (`str`, *opcional*, valor predeterminado `"cpu"`) : El dispositivo en el que se asignarán los tensores. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que impone una longitud mínima de tokens nuevos estableciendo la probabilidad del token EOS (End-Of-Sequence) en 0. A diferencia de [MinLengthLogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.MinLengthLogitsProcessor), este procesor ignora el prompt. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer(["A number:"], return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one >>> # setting `min_new_tokens` will force the model to generate beyond its natural ending point, which is not >>> # necessarily incorrect >>> gen_out = model.generate(**inputs, min_new_tokens=2) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) A number: one thousand ``` #### __llamada__[[transformers.MinNewTokensLengthLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L226) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.MinPLogitsWarper[[transformers.MinPLogitsWarper]] ```python transformers.MinPLogitsWarper(min_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L733) **Parámetros:** min_p (`float`) : Probabilidad mínima del token, que se escalará por la probabilidad del token más probable. Debe ser un valor entre 0 y 1. Los valores típicos están en el rango de 0.01 a 0.2, con una selectividad comparable a la de establecer `top_p` en el rango de 0.99 a 0.8 (utilice el opuesto de los valores normales de `top_p`). filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores filtrados se establecerán en este valor float. min_tokens_to_keep (`int`, *opcional*, valor predeterminado 1) : Número mínimo de tokens que no se pueden filtrar. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que realiza min-p, es decir, conserva todos los tokens cuya probabilidad supere un mínimo, escalado por la probabilidad del token más probable. Como resultado, el filtro se vuelve más agresivo en presencia de tokens de alta probabilidad, lo cual es un indicio de una salida confiable de la que no deberíamos desviarnos. Se utiliza a menudo junto con [TemperatureLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TemperatureLogitsWarper). Se usa como alternativa a [TopPLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TopPLogitsWarper) y [TopKLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TopKLogitsWarper). Creado por @menhguin y @kalomaze (nombres de usuario de GitHub). Código adaptado de [esta PR externa](https://github.com/oobabooga/text-generation-webui/pull/4449/files) Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With `min_p` sampling, the output gets restricted to high-probability tokens. >>> # Pro tip: In practice, LLMs use `min_p` in the 0.01-0.2 range. >>> outputs = model.generate(**inputs, do_sample=True, min_p=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __llamada__[[transformers.MinPLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L790) #### transformers.NoBadWordsLogitsProcessor[[transformers.NoBadWordsLogitsProcessor]] ```python transformers.NoBadWordsLogitsProcessor(bad_words_ids: list, eos_token_id: typing.Union[int, list[int], torch.Tensor, NoneType] = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1426) **Parámetros:** bad_words_ids (`list[list[int]]`) : Lista de listas de ids de tokens que no se permiten generar. eos_token_id (`Union[int, list[int], torch.Tensor]`, *opcional*) : El o los id del token *end-of-sequence*. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que garantiza que las secuencias especificadas nunca serán seleccionadas. Para obtener los ids de los tokens de las palabras que no deben aparecer en el texto generado, asegúrate de establecer `add_prefix_space=True` al inicializar el tokenizador y usa `tokenizer(bad_words, add_special_tokens=False).input_ids`. El argumento `add_prefix_space` solo se admite en algunos tokenizadores lentos, ya que el comportamiento de prefijado de los tokenizadores rápidos proviene de `pre tokenizers`. Lee más [aquí](https://huggingface.co/docs/tokenizers/api/pre-tokenizers). Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> inputs = tokenizer(["In a word, the cake is a"], return_tensors="pt") >>> output_ids = model.generate(inputs["input_ids"], max_new_tokens=5, pad_token_id=tokenizer.eos_token_id) >>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]) In a word, the cake is a bit of a mess. >>> # Now let's take the bad words out. Please note that the tokenizer is initialized differently >>> tokenizer_with_prefix_space = AutoTokenizer.from_pretrained("openai-community/gpt2", add_prefix_space=True) >>> def get_tokens_as_list(word_list): ... "Converts a sequence of words into a list of tokens" ... tokens_list = [] ... for word in word_list: ... tokenized_word = tokenizer_with_prefix_space([word], add_special_tokens=False).input_ids[0] ... tokens_list.append(tokenized_word) ... return tokens_list >>> bad_words_ids = get_tokens_as_list(word_list=["mess"]) >>> output_ids = model.generate( ... inputs["input_ids"], max_new_tokens=5, bad_words_ids=bad_words_ids, pad_token_id=tokenizer.eos_token_id ... ) >>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]) In a word, the cake is a bit of a surprise. ``` #### __llamada__[[transformers.NoBadWordsLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.NoRepeatNGramLogitsProcessor[[transformers.NoRepeatNGramLogitsProcessor]] ```python transformers.NoRepeatNGramLogitsProcessor(ngram_size: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1102) **Parámetros:** ngram_size (`int`) : Todos los ngramas de tamaño `ngram_size` solo pueden ocurrir una vez. Los n-gramas son grupos de "n" palabras, caracteres o tokens consecutivos extraídos de una secuencia de texto. Dada la oración: "She runs fast", los bi-gramas (n=2) serían ("she", "runs") y ("runs", "fast"). En la generación de texto, evitar la repetición de secuencias de palabras proporciona una salida más diversa. Este [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) impide la repetición de n-gramas estableciendo las puntuaciones de los tokens prohibidos en negativo infinito, lo que elimina dichos tokens de la consideración al procesar las puntuaciones posteriormente. Tenga en cuenta que, en el caso de modelos solo decodificadores como la mayoría de los LLM, el prompt también se considera para obtener los n-gramas. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345). Utilice las penalizaciones de n-gramas con precaución. Por ejemplo, penalizar los 2-gramas (bigramas) en un artículo sobre la ciudad de Nueva York podría dar lugar a resultados no deseados en los que el nombre de la ciudad aparezca solo una vez en todo el texto. [Referencia](https://huggingface.co/blog/how-to-generate) Ejemplos: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer(["Today I"], return_tensors="pt") >>> output = model.generate(**inputs) >>> print(tokenizer.decode(output[0], skip_special_tokens=True)) Today I'm not sure if I'm going to be able to do it. >>> # Now let's add ngram size using `no_repeat_ngram_size`. This stops the repetitions ("I'm") in the output. >>> output = model.generate(**inputs, no_repeat_ngram_size=2) >>> print(tokenizer.decode(output[0], skip_special_tokens=True)) Today I'm not sure if I can get a better understanding of the nature of this issue ``` #### __llamada__[[transformers.NoRepeatNGramLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1149) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.PrefixConstrainedLogitsProcessor[[transformers.PrefixConstrainedLogitsProcessor]] ```python transformers.PrefixConstrainedLogitsProcessor(prefix_allowed_tokens_fn: Callable, num_beams: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1515) **Parámetros:** prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : Esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Esta función toma dos argumentos, `inputs_ids` y el ID del lote `batch_id`. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación, condicionada a los tokens generados previamente `inputs_ids` y al ID del lote `batch_id`. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que aplica generación restringida y resulta útil para la generación restringida condicionada por prefijo. Consulte [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) para obtener más información. Ejemplos: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("Alice and Bob", return_tensors="pt") >>> # By default, it continues generating according to the model's logits >>> outputs = model.generate(**inputs, max_new_tokens=5) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice and Bob are friends >>> # We can constrain it with `prefix_allowed_tokens_fn` to force a certain behavior based on a prefix. >>> # For instance, we can force an entire entity to be generated when its beginning is detected. >>> entity = tokenizer(" Bob Marley", return_tensors="pt").input_ids[0] # 3 tokens >>> def prefix_allowed_tokens_fn(batch_id, input_ids): ... ''' ... Attempts to generate 'Bob Marley' when 'Bob' is detected. ... In this case, `batch_id` is not used, but you can set rules for each batch member. ... ''' ... if input_ids[-1] == entity[0]: ... return [entity[1].item()] ... elif input_ids[-2] == entity[0] and input_ids[-1] == entity[1]: ... return [entity[2].item()] ... return list(range(tokenizer.vocab_size)) # If no match, allow all tokens >>> outputs = model.generate(**inputs, max_new_tokens=5, prefix_allowed_tokens_fn=prefix_allowed_tokens_fn) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) Alice and Bob Marley ``` #### __llamada__[[transformers.PrefixConstrainedLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1566) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.RepetitionPenaltyLogitsProcessor[[transformers.RepetitionPenaltyLogitsProcessor]] ```python transformers.RepetitionPenaltyLogitsProcessor(penalty: float, prompt_ignore_length: typing.Union[int, torch.Tensor, NoneType] = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L306) **Parámetros:** penalty (`float`) : El parámetro para la penalización de repetición. 1.0 significa sin penalización. Valores superiores a 1.0 penalizan los tokens generados previamente. Valores entre 0.0 y 1.0 premian los tokens generados previamente. prompt_ignore_length (`int` o `torch.LongTensor`, *opcional*) : Número de tokens iniciales a ignorar, especificado opcionalmente por elemento del lote. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que previene la repetición de tokens anteriores mediante una penalización. Esta penalización se aplica como máximo una vez por token. Tenga en cuenta que, en el caso de modelos solo decodificador como la mayoría de los LLM, los tokens considerados incluyen el prompt de forma predeterminada. En el [artículo](https://huggingface.co/papers/1909.05858) original, los autores sugieren el uso de una penalización de alrededor de 1.2 para lograr un buen equilibrio entre la generación veraz y la falta de repetición. Para penalizar y reducir la repetición, use valores de `penalty` superiores a 1.0, donde un valor más alto penaliza con mayor fuerza. Para recompensar y fomentar la repetición, use valores de `penalty` entre 0.0 y 1.0, donde un valor más bajo recompensa con mayor fuerza. Ejemplos: ```py >>> from transformers import AutoTokenizer, AutoModelForCausalLM, RepetitionPenaltyLogitsProcessor >>> # Initializing the model and tokenizer for it >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer(["I'm not going to"], return_tensors="pt") >>> # This shows a normal generate without any specific parameters >>> summary_ids = model.generate(**inputs) >>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0]) I'm not going to be able to do that. I'm going to be able to do that >>> # This generates a penalty for repeated tokens >>> penalized_ids = model.generate(**inputs, repetition_penalty=1.1) >>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0]) I'm not going to be able to do that. I'll just have to go out and play >>> # We can also exclude the input prompt by creating an instance of this class >>> # with a `prompt_ignore_length` and passing it as a custom logit processor >>> rep_pen_processor = RepetitionPenaltyLogitsProcessor( ... penalty=1.1, ... prompt_ignore_length=inputs["input_ids"].shape[-1] ... ) >>> penalized_ids = model.generate(**inputs, logits_processor=[rep_pen_processor]) >>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0]) I'm not going to be able to do that. I'm going to have to go through a lot of things, and ``` #### __llamada__[[transformers.RepetitionPenaltyLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L373) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.SequenceBiasLogitsProcessor[[transformers.SequenceBiasLogitsProcessor]] ```python transformers.SequenceBiasLogitsProcessor(sequence_bias: list) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1242) **Parámetros:** sequence_bias (`list[list[Union[list[int], float]]]`) : Lista de listas que asigna a una secuencia de tokens su término de sesgo (p. ej. `[[[10, 45], -2.0], [[64], -7.5]]`). Los sesgos positivos aumentan la probabilidad de que la secuencia sea seleccionada, mientras que los sesgos negativos hacen lo contrario. Si una secuencia tiene una longitud de 1, su sesgo se aplicará siempre. En caso contrario, el sesgo solo se aplicará si la secuencia en cuestión está a punto de completarse (en el paso de selección de tokens posterior a la aplicación de este procesador). [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que aplica un sesgo aditivo a las secuencias. El sesgo se aplica al último token de una secuencia cuando el token generado a continuación puede completarla. En consecuencia, para aprovechar al máximo el sesgo en secuencias de más de un token, considere utilizar métodos de beam (para manejar adecuadamente las secuencias parcialmente completadas que tienen un sesgo negativo) y aplicar el sesgo a sus prefijos (para garantizar que el sesgo se aplique antes). A nivel de token, sesgar una palabra es diferente de sesgar una palabra con un espacio antes de ella. Si deseas sesgar "foo" a mitad de una oración, probablemente quieras añadir un espacio de prefijo y sesgar " foo" en su lugar. Consulta la sección del tokenizador de nuestro curso de NLP para saber por qué: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct") >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct") >>> inputs = tokenizer(["The full name of Donald is Donald"], return_tensors="pt") >>> summary_ids = model.generate(inputs["input_ids"], max_new_tokens=4, do_sample=False) >>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald John Trump Sr. >>> def get_tokens(word): ... return tokenizer([word], add_special_tokens=False).input_ids[0] >>> # IMPORTANT: Remember our tip about adding spaces before words to bias them correctly. >>> sequence_bias = [[get_tokens("Trump"), -10.0],] # will fail to apply bias >>> biased_ids = model.generate( ... inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias ... ) >>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald John Trump Sr. >>> sequence_bias = [[get_tokens(" Trump"), -10.0],] # will work >>> biased_ids = model.generate( ... inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias ... ) >>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald John Harper. He >>> # We can also add a positive bias to nudge the model towards specific tokens or continuations. This technique >>> # is also more effective when paired up with beam search. >>> sequence_bias = [[get_tokens(" Donald Duck"), 10.0],] >>> biased_ids = model.generate( ... inputs["input_ids"], max_new_tokens=4, num_beams=4, do_sample=False, sequence_bias=sequence_bias ... ) >>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0]) The full name of Donald is Donald Duck. He is ``` #### __llamada__[[transformers.SequenceBiasLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.SuppressTokensAtBeginLogitsProcessor[[transformers.SuppressTokensAtBeginLogitsProcessor]] ```python transformers.SuppressTokensAtBeginLogitsProcessor(begin_suppress_tokens, begin_index, device: str = 'cpu') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1851) [SuppressTokensAtBeginLogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor) suprime una lista de tokens en cuanto la función `generate` comienza a generar, utilizando los tokens `begin_index`. Esto debe garantizar que los tokens definidos por `begin_suppress_tokens` no se generen al inicio. Creado originalmente para [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper). Ejemplos: ```python >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> # Whisper has `begin_suppress_tokens` set by default (= `[220, 50256]`). 50256 is the EOS token, so this means >>> # it can't generate and EOS token in the first iteration, but it can in the others. >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) >>> print(outputs.scores[0][0, 50256]) tensor(-inf) >>> print(outputs.scores[-1][0, 50256]) # in other places we can see some probability mass for EOS tensor(29.9010) >>> # If we disable `begin_suppress_tokens`, we can generate EOS in the first iteration. >>> outputs = model.generate( ... **inputs, return_dict_in_generate=True, output_scores=True, begin_suppress_tokens=None ... ) >>> print(outputs.scores[0][0, 50256]) tensor(11.2027) ``` #### __llamada__[[transformers.SuppressTokensAtBeginLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1893) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.SuppressTokensLogitsProcessor[[transformers.SuppressTokensLogitsProcessor]] ```python transformers.SuppressTokensLogitsProcessor(suppress_tokens, device: str = 'cpu') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1904) Este procesador se puede utilizar para suprimir una lista de tokens. El procesador establecerá sus log probs en `-inf` para que no se generen. Creado originalmente para [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper). Ejemplos: ```python >>> from transformers import AutoProcessor, WhisperForConditionalGeneration >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt") >>> # Whisper has a long list of suppressed tokens. For instance, in this case, the token 1 is suppressed by default. >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True) >>> print(outputs.scores[1][0, 1]) # 1 (and not 0) is the first freely generated token tensor(-inf) >>> # If we disable `suppress_tokens`, we can generate it. >>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True, suppress_tokens=None) >>> print(outputs.scores[1][0, 1]) tensor(6.0678) ``` #### __llamada__[[transformers.SuppressTokensLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1936) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.SynthIDTextWatermarkLogitsProcessor[[transformers.SynthIDTextWatermarkLogitsProcessor]] ```python transformers.SynthIDTextWatermarkLogitsProcessor(ngram_len: int, keys: list, sampling_table_size: int, sampling_table_seed: int, context_history_size: int, device: device, skip_first_ngram_calls: bool = False, debug_mode: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2605) **Parámetros:** ngram_len (`int`) : Longitud del n-grama. keys (`list[int]`) : Una secuencia de claves de marca de agua, una para cada profundidad. sampling_table_size (`int`) : Tamaño de la tabla de muestreo. sampling_table_seed (`int`) : Semilla aleatoria para generar la tabla de muestreo. context_history_size (`int`) : Tamaño del tensor para llevar un registro de los contextos vistos. device (`torch.device`) : Dispositivo a utilizar. skip_first_ngram_calls (`bool`, *opcional*, valor predeterminado `False`) : Si se deben omitir las primeras llamadas a ngram. debug_mode (`bool`, *opcional*, valor predeterminado `False`) : Los logits se modifican a uno uniforme antes de que se aplique la modificación del marca de agua. Esto sirve para probar la implementación. Procesador de logits que implementa técnicas de marca de agua para modelos de generación de texto. Esta clase facilita la aplicación de la marca de agua de texto SynthID, un método para incrustar señales imperceptibles en el texto generado con el fin de ayudar a detectar contenido sintético. Funciona manipulando sutilmente las probabilidades de selección de tokens durante la generación de texto de una manera que puede recuperarse de forma fiable más adelante para su verificación. Características principales: * **Gestión del estado:** Mantiene un estado interno para seguir las secuencias de tokens y generar las claves de marca de agua dinámicamente. * **Generación de claves:** Calcula hashes basados en secuencias de tokens y parámetros de marca de agua para crear claves únicas para cada posición. * **Muestreo de valores G:** Utiliza una tabla de muestreo precalculada para muestrear los valores de marca de agua (valores g) en función de las claves generadas. * **Ajuste de puntuación:** Aplica los valores g calculados para modificar las probabilidades de los tokens durante la generación, integrando marca de agua. * **Gestión de la repetición del contexto:** Incorpora lógica para evitar la marca de agua en tokens dentro de contextos repetidos, preservando la naturalidad. * **Máscara de tokens EOS:** Permite aplicar una máscara a los tokens de fin de oración para evitar que se incluyan en el marcaje de agua cálculos. * **Funciones de utilidad:** Proporciona funciones para calcular los valores g directamente, comprobar la repetición de contexto, crear Máscaras de tokens EOS, y estimar los valores g medios esperados. Consulte la URL del artículo: https://www.nature.com/articles/s41586-024-08025-4 para obtener más detalles al respecto. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig >>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left") >>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b') >>> # SynthID Text configuration >>> watermarking_config = SynthIDTextWatermarkingConfig( ... keys=[654, 400, 836, 123, 340, 443, 597, 160, 57], ... ngram_len=5, ... ) >>> # Generation with watermarking >>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True) >>> output_sequences = model.generate( ... **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10 ... ) >>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True) ``` #### __llamada__[[transformers.SynthIDTextWatermarkLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2743) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.TemperatureLogitsWarper[[transformers.TemperatureLogitsWarper]] ```python transformers.TemperatureLogitsWarper(temperature: float) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L238) **Parámetros:** temperature (`float`) : Valor float estrictamente positivo utilizado para modular la distribución de logits. Un valor menor que `1` disminuye la aleatoriedad (y viceversa), siendo `0` equivalente a desplazar toda la masa de probabilidad al token más probable. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) para la temperatura (escalado exponencial de la distribución de probabilidad de salida), lo que significa en la práctica que puede controlar la aleatoriedad de los tokens predichos. Se suele usar junto con [TopPLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TopPLogitsWarper) y [TopKLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TopKLogitsWarper). Asegúrate de que `do_sample=True` esté incluido en los argumentos de `generate`; de lo contrario, el valor de la temperatura no tendrá ningún efecto. Ejemplos: ```python >>> import torch >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(0) # for reproducibility >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> model.config.pad_token_id = model.config.eos_token_id >>> inputs = tokenizer(["Hugging Face Company is"], return_tensors="pt") >>> # With temperature=1.0, the default, we consistently get random outputs due to random sampling. >>> generate_kwargs = {"max_new_tokens": 10, "do_sample": True, "temperature": 1.0, "num_return_sequences": 2} >>> outputs = model.generate(**inputs, **generate_kwargs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)) ['Hugging Face Company is one of these companies that is going to take a', "Hugging Face Company is a brand created by Brian A. O'Neil"] >>> # However, with temperature close to 0, it approximates greedy decoding strategies (invariant) >>> generate_kwargs["temperature"] = 0.0001 >>> outputs = model.generate(**inputs, **generate_kwargs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)) ['Hugging Face Company is a company that has been around for over 20 years', 'Hugging Face Company is a company that has been around for over 20 years'] ``` #### __llamada__[[transformers.TemperatureLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L300) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.TopHLogitsWarper[[transformers.TopHLogitsWarper]] ```python transformers.TopHLogitsWarper(top_h: float, filter_value: float = -inf) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L627) **Parámetros:** top_h (`float`) : Coeficiente de escalado para el umbral basado en entropía (`tau`). Debe estar en el rango `(0, 1]`. filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores filtrados se establecerán en este valor float. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que implementa la muestreo Top-H, un método de decodificación que selecciona de forma adaptativa un subconjunto de tokens de alta probabilidad en función de restricciones de entropía y probabilidad acumulada. Este método determina dinámicamente cuántos tokens conservar analizando la diferencia de entropía de la distribución seleccionada, equilibrando así la exploración y la explotación. Garantiza que el texto generado mantenga tanto diversidad como coherencia. Referencia: Para más detalles, consulte *Top-H Decoding: Adapting the Creativity and Coherence with Bounded Entropy in Text Generation* (NeurIPS 2025): https://arxiv.org/abs/2509.02510 Ejemplo: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B") >>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> outputs = model.generate(**inputs, do_sample=True, top_h=0.4) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __llamada__[[transformers.TopHLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L678) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : IDs de tokens de entrada. scores (`torch.Tensor` de forma `(batch_size, vocab_size)`) : Logits crudos del modelo. **Devuelve:** `torch.Tensor` de forma `(batch_size, vocab_size)` Logits procesados donde los tokens no válidos se enmascaran con `-inf`. Filtra los logits mediante muestreo Top-H. #### transformers.TopKLogitsWarper[[transformers.TopKLogitsWarper]] ```python transformers.TopKLogitsWarper(top_k: int, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L571) **Parámetros:** top_k (`int`) : El número de tokens del vocabulario con mayor probabilidad que se deben conservar para el filtrado top-k. filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores filtrados se establecerán en este valor float. min_tokens_to_keep (`int`, *opcional*, valor predeterminado 1) : Número mínimo de tokens que no se pueden filtrar. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que realiza top-k, es decir, restringe a los k elementos con mayor probabilidad. A menudo se utiliza junto con [TemperatureLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TemperatureLogitsWarper) y [TopPLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TopPLogitsWarper). Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: A, B, C, D", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: A, B, C, D, E — S — O, P — R >>> # With `top_k` sampling, the output gets restricted the k most likely tokens. >>> # Pro tip: In practice, LLMs use `top_k` in the 5-50 range. >>> outputs = model.generate(**inputs, do_sample=True, top_k=2) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: A, B, C, D, E, F, G, H, I ``` #### __llamada__[[transformers.TopKLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L618) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.TopPLogitsWarper[[transformers.TopPLogitsWarper]] ```python transformers.TopPLogitsWarper(top_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L502) **Parámetros:** top_p (`float`) : Si se establece en un valor < 1, solo se conservan para la generación el conjunto más pequeño de tokens más probables cuyas probabilidades suman `top_p` o más. filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores filtrados se establecerán en este valor float. min_tokens_to_keep (`int`, *opcional*, valor predeterminado 1) : Número mínimo de tokens que no se pueden filtrar. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que realiza top-p, es decir, restringe a los tokens superiores cuya suma de probabilidades sea <= prob_cut_off. Se utiliza a menudo junto con [TemperatureLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TemperatureLogitsWarper) y [TopKLogitsWarper](/docs/transformers/main/es/internal/generation_utils#transformers.TopKLogitsWarper). Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> set_seed(1) >>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2") >>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2") >>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt") >>> # With sampling, the output is unexpected -- sometimes too unexpected. >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3 | < 4 (left-hand pointer) ; >>> # With `top_p` sampling, the output gets restricted to high-probability tokens. >>> # Pro tip: In practice, LLMs use `top_p` in the 0.9-0.95 range. >>> outputs = model.generate(**inputs, do_sample=True, top_p=0.1) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9 ``` #### __llamada__[[transformers.TopPLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L555) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.TypicalLogitsWarper[[transformers.TypicalLogitsWarper]] ```python transformers.TypicalLogitsWarper(mass: float = 0.9, filter_value: float = -inf, min_tokens_to_keep: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L809) **Parámetros:** mass (`float`, *opcional*, valor predeterminado 0.9) : Valor de typical_p entre 0 y 1 (ambos inclusive), valor predeterminado 0.9. filter_value (`float`, *opcional*, valor predeterminado: -inf) : Todos los valores filtrados se establecerán en este valor float. min_tokens_to_keep (`int`, *opcional*, valor predeterminado 1) : Número mínimo de tokens que no se pueden filtrar. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que realiza una decodificación típica. Inspirado en cómo los humanos usan el lenguaje, prioriza los tokens cuya probabilidad logarítmica se acerca a la entropía de la distribución de probabilidad de tokens. Esto significa que los tokens más probables pueden descartarse durante el proceso. Consulte [Decodificación típica para la generación de lenguaje natural](https://huggingface.co/papers/2202.00666) para obtener más información. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed >>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m") >>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m") >>> inputs = tokenizer("1, 2, 3", return_tensors="pt") >>> # We can see that greedy decoding produces a sequence of numbers >>> outputs = model.generate(**inputs) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, >>> # For this particular seed, we can see that sampling produces nearly the same low-information (= low entropy) >>> # sequence >>> set_seed(18) >>> outputs = model.generate(**inputs, do_sample=True) >>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]) 1, 2, 3, 4, 5, 6, 7, 8, 9 and 10 >>> # With `typical_p` set, the most obvious sequence is no longer produced, which may be good for your problem >>> set_seed(18) >>> outputs = model.generate( ... **inputs, do_sample=True, typical_p=0.1, return_dict_in_generate=True, output_scores=True ... ) >>> print(tokenizer.batch_decode(outputs.sequences, skip_special_tokens=True)[0]) 1, 2, 3 and 5 >>> # We can see that the token corresponding to "4" (token 934) in the second position, the most likely token >>> # as seen with greedy decoding, was entirely blocked out >>> print(outputs.scores[1][0, 934]) tensor(-inf) ``` #### __llamada__[[transformers.TypicalLogitsWarper.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L873) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor]] ```python transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor(guidance_scale: float, model, unconditional_ids: typing.Optional[torch.LongTensor] = None, unconditional_attention_mask: typing.Optional[torch.LongTensor] = None, use_cache: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2267) **Parámetros:** guidance_scale (`float`) : La escala de guía para la guía libre de clasificador (CFG). CFG se habilita estableciendo `guidance_scale != 1`. Una escala de guía más alta anima al modelo a generar muestras más estrechamente vinculadas al prompt de entrada, generalmente a costa de una menor calidad. Un valor menor que 1 tiene el efecto contrario, haciendo que el prompt negativo proporcionado con negative_prompt_ids (si lo hay) actúe como un prompt positivo. model (`PreTrainedModel`): el modelo que calcula las puntuaciones incondicionales. Presumiblemente, es el mismo que calcula las puntuaciones condicionales. Ambos modelos deben utilizar el mismo tokenizer. unconditional_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario para la rama incondicional. Si no se establece, se usará por defecto el último token del prompt. unconditional_attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara de atención para unconditional_ids. use_cache (`bool`, *opcional*, valor predeterminado `True`) : Si se deben cachear las claves/valores durante la pasada de propagación hacia adelante del prompt negativo. Procesador de logits para Classifier-Free Guidance (CFG). Los procesadores calculan una media ponderada entre las puntuaciones de los logits condicionados por el prompt y los logits incondicionales (o negativos) del prompt, parametrizada por `guidance_scale`. Las puntuaciones incondicionales se calculan internamente solicitando a `model` que use la rama `unconditional_ids`. Consulte [el artículo](https://huggingface.co/papers/2306.17806) para obtener más información. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> inputs = tokenizer(["Today, a dragon flew over Paris, France,"], return_tensors="pt") >>> out = model.generate(inputs["input_ids"], guidance_scale=1.5) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Today, a dragon flew over Paris, France, killing at least 50 people and injuring more than 100' >>> # with a negative prompt >>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt") >>> out = model.generate(inputs["input_ids"], guidance_scale=2, negative_prompt_ids=neg_inputs["input_ids"]) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Today, a dragon flew over Paris, France, killing at least 130 people. French media reported that' >>> # with a positive prompt >>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt") >>> out = model.generate(inputs["input_ids"], guidance_scale=0, negative_prompt_ids=neg_inputs["input_ids"]) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] "Today, a dragon flew over Paris, France, and I'm very happy to be here. I" ``` #### __llamada__[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor.__call__]] ```python __call__(input_ids, scores) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2373) #### transformers.WhisperTimeStampLogitsProcessor[[transformers.WhisperTimeStampLogitsProcessor]] ```python transformers.WhisperTimeStampLogitsProcessor(generate_config: GenerationConfig, begin_index: int, _detect_timestamp_from_logprob: bool | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1944) **Parámetros:** generate_config (`GenerateConfig`) : La configuración de generación utilizada para generar la salida. Los siguientes parámetros son obligatorios: eos_token_id (`int`, *opcional*, valor predeterminado 50257): El id del token de *fin de secuencia*. no_timestamps_token_id (`int`, *opcional*, valor predeterminado 50363): El id del token `"<|notimestamps|>"`. max_initial_timestamp_index (`int`, *opcional*, valor predeterminado 1): Se utiliza para establecer el valor máximo del timestamp inicial. Esto se usa para evitar que el modelo prediga timestamps demasiado lejanos en el futuro. begin_index (`int`) : Índice del token del primer token generado por el modelo. _detect_timestamp_from_logprob (`bool`, *opcional*) : Si se pueden predecir marcas de tiempo a partir de logprobs sobre todas las marcas de tiempo. [LogitsProcessor](/docs/transformers/main/es/internal/generation_utils#transformers.LogitsProcessor) que modifica los logits para la generación de marcas de tiempo en la transcripción. Cuando los tokens de entrada alcanzan un umbral específico, el procesador establece las puntuaciones en negativo infinito. El procesador se asegura de que los tokens de marca de tiempo aparezcan en pares, enmascarando los logits que romperían este patrón de emparejamiento. Esto se hace para mantener la consistencia y la estructura de las marcas de tiempo generadas. También garantiza que, cuando la probabilidad predicha de muestrear cualquier token de marca de tiempo es mayor que la de cualquier token individual que no sea de marca de tiempo, esos logits no relacionados con marcas de tiempo se establezcan en negativo infinito. Esto se hace para asegurar la generación de marcas de tiempo en lugar de otros tokens potenciales. Consulte [el artículo](https://huggingface.co/papers/2212.04356) para obtener más información. Ejemplos: ``` python >>> import torch >>> from transformers import AutoProcessor, WhisperForConditionalGeneration, GenerationConfig >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en") >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en") >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation") >>> inputs = processor(ds[3]["audio"]["array"], return_tensors="pt") >>> input_features = inputs.input_features >>> #Displaying timestamps >>> generated_ids = model.generate(inputs=input_features, return_timestamps=True) >>> transcription = processor.batch_decode(generated_ids, decode_with_timestamps=True)[0] >>> print("Transcription:", transcription) Transcription: <|startoftranscript|><|0.00|> He has grave doubts whether Sir Frederick Layton's work is really Greek after all, and can<|6.44|><|6.44|> discover in it but little of rocky Ithaca.<|9.44|><|endoftext|> >>> #No timestamps & change EOS: >>> #This allows the user to select a specific token to terminate the sequence on, in this case it's the word "can"(460) >>> model.generation_config.eos_token_id = 460 >>> generated_ids = model.generate(inputs=input_features,return_timestamps=False) >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> print("Transcription:", transcription) Transcription: He has grave doubts whether Sir Frederick Layton's work is really Greek after all and can ``` #### __llamada__[[transformers.WhisperTimeStampLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2034) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. #### transformers.WatermarkLogitsProcessor[[transformers.WatermarkLogitsProcessor]] ```python transformers.WatermarkLogitsProcessor(vocab_size, device, greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2432) **Parámetros:** vocab_size (`int`) : vocab_size del tokenizador del modelo. Se utiliza para calcular la proporción de tokens "green". device (`str`) : El dispositivo donde se asigna el modelo. greenlist_ratio (`float`, opcional, *optional*, valor predeterminado 0.25) : La proporción de tokens "verdes" en relación con el tamaño del vocabulario. El valor predeterminado es 0.25. bias (`float`, opcional, *opcional*, valor predeterminado 2.0) : El sesgo que se suma a los logits de los tokens "verdes" seleccionados. Considere reducir el `bias` si la calidad de la generación de texto se degrada. Los valores recomendados están en el rango [0.5, 2.0]. El valor predeterminado es 2.0. hashing_key (`int`, opcional, *opcional*, valor predeterminado 15485863) : Clave utilizada para el hash. Si implementa esta marca de agua, le recomendamos utilizar otra clave privada. El valor predeterminado es 15485863 (el millón primo). seeding_scheme (`str`, opcional, *optional*, valor predeterminado `"lefthash"`) : El esquema de siembra utilizado para seleccionar los tokens "green". Acepta los valores: - "lefthash" (predeterminado): la selección de tokens "green" depende del último token (Algoritmo 2 del artículo) - "selfhash": la selección de tokens "green" depende del token actual (Algoritmo 3 del artículo) La desventaja de este esquema es que considera todos los tokens siguientes posibles y puede ser más lento que "lefthash". La longitud de contexto de los tokens anteriores que se utilizará en la siembra. Una longitud de contexto mayor hace que el marcaje de agua sea más robusto. context_width (`int`, *opcional*, valor predeterminado: 1) : El número de tokens anteriores que se utilizarán al establecer la semilla. Procesador de logits para aplicar marcas de agua al texto generado. El procesador modifica las puntuaciones de salida del modelo añadiendo un pequeño sesgo a un conjunto aleatorio de tokens "green" antes de generar el siguiente token. El proceso de selección de los tokens "green" depende del `seeding_scheme` utilizado. El código se basó en el [repositorio original](https://github.com/jwkirchenbauer/lm-watermarking/tree/main). El texto generado por este `LogitsProcessor` puede detectarse mediante `WatermarkDetector`. Consulte [__call__()](/docs/transformers/main/es/internal/generation_utils#transformers.WatermarkDetector.__call__) para más detalles, Consulte [el artículo](https://huggingface.co/papers/2306.04634) para obtener más información. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkingConfig >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> inputs = tokenizer(["Alice and Bob are"], return_tensors="pt") >>> # normal generation >>> out = model.generate(inputs["input_ids"], max_length=20, do_sample=False) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Alice and Bob are both in the same room.\n\n"I\'m not sure if you\'re' >>> # watermarked generation >>> watermarking_config = WatermarkingConfig(bias=2.5, context_width=2, seeding_scheme="selfhash") >>> out = model.generate(inputs["input_ids"], watermarking_config=watermarking_config, max_length=20, do_sample=False) >>> tokenizer.batch_decode(out, skip_special_tokens=True)[0] 'Alice and Bob are both still alive and well and the story is pretty much a one-hour adventure' >>> # to detect watermarked text use the WatermarkDetector class >>> from transformers import WatermarkDetector >>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config= watermarking_config) >>> detection_preds = detector(out) >>> detection_preds array([ True]) ``` #### __llamada__[[transformers.WatermarkLogitsProcessor.__call__]] ```python __call__(input_ids: LongTensor, scores: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2554) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. [¿Qué son los IDs de entrada?](../glossary#input-ids) scores (`torch.Tensor` de forma `(batch_size, config.vocab_size)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje. Estas pueden ser logits para cada vocabulario cuando no se utiliza la búsqueda por haces o log softmax para cada token del vocabulario cuando se utiliza la búsqueda por haces **Devuelve:** `torch.Tensor` de forma `(batch_size, config.vocab_size)` Las puntuaciones de predicción procesadas. ## StoppingCriteria[[transformers.StoppingCriteria]] Se puede usar un [StoppingCriteria](/docs/transformers/main/es/internal/generation_utils#transformers.StoppingCriteria) para cambiar cuándo detener la generación (además del token EOS). Tenga en cuenta que esto está disponible exclusivamente en nuestras implementaciones de PyTorch. #### transformers.StoppingCriteria[[transformers.StoppingCriteria]] ```python transformers.StoppingCriteria() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L48) Clase base abstracta para todos los criterios de parada que se pueden aplicar durante la generación. Si su criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`. #### __llamada__[[transformers.StoppingCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L55) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje, como una tupla con un tensor por paso de generación, cada uno de forma `(batch_size, config.vocab_size)`. Estas pueden ser puntuaciones para cada token del vocabulario antes de SoftMax o puntuaciones para cada token del vocabulario después de SoftMax. Si este criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`, de lo contrario se pasa `None`. kwargs (`dict[str, Any]`, *opcional*) : Palabras clave adicionales específicas para los criterios de parada. **Devuelve:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`) `True` indica que detenemos la generación para una fila en particular. `False` indica que debemos continuar. #### transformers.StoppingCriteriaList[[transformers.StoppingCriteriaList]] ```python transformers.StoppingCriteriaList(iterable = ()) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L610) #### __llamada__[[transformers.StoppingCriteriaList.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L611) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje, como una tupla con un tensor por paso de generación, cada uno de forma `(batch_size, config.vocab_size)`. Estas pueden ser puntuaciones para cada token del vocabulario antes de SoftMax o puntuaciones para cada token del vocabulario después de SoftMax. Si este criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`, de lo contrario se pasa `None`. kwargs (`dict[str, Any]`, *opcional*) : Palabras clave adicionales específicas para los criterios de parada. **Devuelve:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`) `True` indica que detenemos la generación para una fila en particular. `False` indica que debemos continuar. #### transformers.MaxLengthCriteria[[transformers.MaxLengthCriteria]] ```python transformers.MaxLengthCriteria(max_length: int, max_position_embeddings: int | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L60) **Parámetros:** max_length (`int`) : La longitud máxima que puede tener la secuencia de salida en número de tokens. max_position_embeddings (`int`, *opcional*) : La longitud máxima del modelo, tal como la define el atributo `config.max_position_embeddings` del modelo. Esta clase se puede utilizar para detener la generación en cualquier momento en que el número total de tokens generados supere `max_length`. Tenga en cuenta que, en el caso de transformers de solo decodificador, esto incluirá los tokens iniciales del prompt. #### __llamada__[[transformers.MaxLengthCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L76) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje, como una tupla con un tensor por paso de generación, cada uno de forma `(batch_size, config.vocab_size)`. Estas pueden ser puntuaciones para cada token del vocabulario antes de SoftMax o puntuaciones para cada token del vocabulario después de SoftMax. Si este criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`, de lo contrario se pasa `None`. kwargs (`dict[str, Any]`, *opcional*) : Palabras clave adicionales específicas para los criterios de parada. **Devuelve:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`) `True` indica que detenemos la generación para una fila en particular. `False` indica que debemos continuar. #### transformers.MaxTimeCriteria[[transformers.MaxTimeCriteria]] ```python transformers.MaxTimeCriteria(max_time: float, initial_timestamp: float | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L89) **Parámetros:** max_time (`float`) : Tiempo máximo permitido en segundos para la generación. initial_timestamp (`float`, *opcional*, valor predeterminado `time.time()`) : El inicio del tiempo permitido para la generación. Esta clase se puede utilizar para detener la generación en cualquier momento en que la generación completa exceda una cantidad de tiempo determinada. De forma predeterminada, el tiempo comienza a contarse cuando se inicializa esta función. Puede sobrescribir este comportamiento pasando un `initial_timestamp`. #### __llamada__[[transformers.MaxTimeCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L106) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje, como una tupla con un tensor por paso de generación, cada uno de forma `(batch_size, config.vocab_size)`. Estas pueden ser puntuaciones para cada token del vocabulario antes de SoftMax o puntuaciones para cada token del vocabulario después de SoftMax. Si este criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`, de lo contrario se pasa `None`. kwargs (`dict[str, Any]`, *opcional*) : Palabras clave adicionales específicas para los criterios de parada. **Devuelve:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`) `True` indica que detenemos la generación para una fila en particular. `False` indica que debemos continuar. #### transformers.StopStringCriteria[[transformers.StopStringCriteria]] ```python transformers.StopStringCriteria(tokenizer: PreTrainedTokenizerBase, stop_strings: str | list[str]) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L112) **Parámetros:** tokenizer (`PreTrainedTokenizer`): el tokenizador asociado al modelo (necesario para extraer el vocabulario y tokenizar las secuencias de terminación) stop_strings (`Union[str, list[str]]`) : Una lista de cadenas que deben finalizar la generación. Si se pasa una cadena, se tratará como una lista con un solo elemento. Esta clase se puede utilizar para detener la generación en cualquier momento que se generen secuencias de caracteres específicas. Preprocesa las cadenas junto con el vocabulario del tokenizador para encontrar las posiciones donde los tokens pueden completar válidamente las cadenas de parada. La generación se detiene en cuanto se genera un token que completa alguna de las cadenas de parada. Queremos detectar cualquier instancia en la que la cadena de parada esté presente en la salida decodificada, lo que significa que también debemos capturar los casos con "sobresalientes" en uno o ambos extremos. Para hacer esto más concreto, para la cadena de parada "stop", cualquiera de las siguientes secuencias de tokens activaría la coincidencia: - ["st", "op"] - ["stop"] - ["st", "opera"] - ["sto", "pper"] - ["las", "topper"] - ["s", "to", "pped"] Tenga en cuenta que solo se activará una coincidencia si la cadena de parada se encuentra al final de la secuencia generada. En otras palabras, estas secuencias no activarán una coincidencia: - ["stop", "at"] - ["st", "op", "at"] - ["st", "opera", "tion"] La razón por la que no hay coincidencia es que la cadena de parada no se superpone con el token final. Si se pueden eliminar uno o más tokens del final de la secuencia sin destruir la cadena de parada, entonces este criterio no coincidirá con esa cadena de parada. Esto es por diseño; ya que esta comprobación se ejecuta después de que se genera cada token, no podemos pasar por alto una cadena de parada válida si se genera, pero no queremos detener la generación solo porque la cadena de parada exista en algún lugar de los input_ids de la entrada anterior. ¿Cómo se realiza realmente la coincidencia? Lo hacemos de una manera bastante confusa, porque queremos que todo el proceso de coincidencia sea compilable con Torch o XLA, lo que significa que no podemos usar métodos de cadena estándar. Sin embargo, es posible, con cierto trabajo, realizar la coincidencia de cadenas con operaciones puras de tensores. Comenzaremos describiendo el algoritmo que usamos con operaciones de cadena estándar, y al final explicaremos cómo se convierte esto en operaciones puras de tensores. La clave del algoritmo es una observación: como la cadena de parada debe superponerse con el final de la secuencia de tokens, podemos comenzar desde el final de la secuencia y trabajar hacia atrás. Específicamente, verificamos que exista una superposición entre el inicio del token final y el final de stop_string, o dicho de otra manera, stop_string[-i:] == token[:i] para algún i > 0. Si observa los ejemplos positivos anteriores, verá que el último token en todos ellos cumple esta propiedad: - ["st", "op"] (la superposición es "op", longitud de superposición == 2) - ["stop"] (la superposición es "stop", longitud de superposición == 4) - ["st", "opera"] (la superposición es "op", longitud de superposición == 2) - ["sto", "pper"] (la superposición es "p", longitud de superposición == 1) - ["las", "topper"] (la superposición es "top", longitud de superposición == 3) - ["s", "to", "pped"] (la superposición es "p", longitud de superposición == 1) Es imposible construir una secuencia coincidente que no tenga esta propiedad (puede verificarlo usted mismo). Sin embargo, aunque esta superposición entre el inicio del token final y el final de la cadena de parada es necesaria para que haya una coincidencia, no es suficiente. También es necesario comprobar que el resto de la secuencia de tokens sea coherente con la cadena de parada. ¿Cómo lo hacemos? Utilicemos ["s", "to", "pped"] como ejemplo. Sabemos que el token final, "pped", tiene una superposición de 1 con la cadena de parada, "stop". Luego retrocedemos al token anterior, "to". Dado que ya hemos coincidido 1 carácter de la cadena de parada, el resto por verificar es "sto". Comprobamos que el siguiente token "to" coincide con el final del resto, y así es. Ahora hemos coincidido 3 caracteres de la cadena de parada, y el resto por coincidir es "s". Retrocedemos de nuevo al token anterior, que también es "s". Esta es una coincidencia, por lo que hemos coincidido con la cadena de parada completa. ¿Cómo funciona cuando los tokens se extienden más allá del inicio de la cadena de parada? Consideremos el ejemplo de ["las", "topper"]. El token final, "topper", tiene una superposición de 3 con la cadena de parada, "stop". Por lo tanto, la parte restante de la cadena de parada que debe coincidir es "s". Volvemos al token anterior, "las". Dado que el resto que debe coincidir es solo "s", con longitud 1, consideramos únicamente el último carácter del token, que es "s". Esto coincide con la cadena de parada, por lo que la cadena completa coincide. ¿Cómo calculamos estas coincidencias con operaciones de tensores? Simplemente: precalculamos de forma eficiente la información necesaria para todos los tokens. Para cada token, calculamos: - Su solapamiento con el final de la cadena de parada, si lo hay - Las posiciones dentro de la cadena de parada donde el token coincide, incluidas las coincidencias que se extienden más allá del inicio. - La longitud total del token Por ejemplo, para el token "pped", calcularíamos una superposición final de 1, sin posiciones de coincidencia internas, y una longitud de 4. Para el token "to", calcularíamos sin superposición final, una única posición de coincidencia interna de 1 (contando desde el final), y una longitud de 2. Para el token "s", calcularíamos sin superposición final, una única posición de coincidencia interna de 3 (nuevamente contando desde el final) y una longitud de 1. Mientras tengamos esta información, podemos ejecutar el algoritmo anterior sin ninguna operación de comparación de cadenas. Simplemente realizamos los siguientes pasos: - Comprueba si el token final tiene una superposición final con la cadena de inicio - Continúe hacia atrás, manteniendo un registro de cuánta parte de la cadena de parada se ha coincidido hasta ahora - En cada punto, compruebe si el siguiente token tiene la posición actual como una de sus posiciones válidas - Continúe hasta que una coincidencia falle o hasta que coincida completamente con la cadena de parada completa Nuevamente, consideremos ["s", "to", "pped"] como ejemplo. "pped" tiene una superposición final de 1, por lo que podemos iniciar una coincidencia. Hasta ahora hemos coincidido 1 carácter, así que verificamos que el siguiente token, "to", tenga 1 como posición válida (nuevamente, contando desde el final). Es así, por lo que añadimos la longitud de "to" a nuestro rastreador de posición. Ahora hemos coincidido 3 caracteres, así que verificamos que el siguiente token, "s", tenga 3 como posición válida. Es así, por lo que añadimos su longitud al rastreador de posición. El rastreador de posición ahora es 4, que es la longitud de la cadena de parada. Hemos coincidido con la cadena de parada completa. En el segundo caso, ["las", "topper"], "topper" tiene una superposición final de 3, por lo que podemos iniciar una coincidencia. Hasta ahora hemos coincidido 3 caracteres, así que comprobamos que el siguiente token "las" tiene 3 como posición válida. Es así, porque permitimos que los tokens coincidan con posiciones que se extienden más allá del inicio de la cadena de parada. Añadimos su longitud al rastreador de posiciones. El rastreador de posiciones ahora es 6, ¡que es mayor que la longitud de la cadena de parada! No obstante, no hay que alarmarse: esto también cuenta como una coincidencia de la cadena de parada. Hemos coincidido con la cadena de parada completa. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2") >>> model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2") >>> inputs = tokenizer("The biggest states in the USA by land area:", return_tensors="pt") >>> gen_out = model.generate(**inputs) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) The biggest states in the USA by land area: - Alaska - Texas - California >>> # Passing one or more stop strings will halt generation after those strings are emitted >>> # Note that generating with stop strings requires you to pass the tokenizer too >>> gen_out = model.generate(**inputs, stop_strings=["Texas"], tokenizer=tokenizer) >>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0]) The biggest states in the USA by land area: - Alaska - Texas ``` #### __llamada__[[transformers.StopStringCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L475) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje, como una tupla con un tensor por paso de generación, cada uno de forma `(batch_size, config.vocab_size)`. Estas pueden ser puntuaciones para cada token del vocabulario antes de SoftMax o puntuaciones para cada token del vocabulario después de SoftMax. Si este criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`, de lo contrario se pasa `None`. kwargs (`dict[str, Any]`, *opcional*) : Palabras clave adicionales específicas para los criterios de parada. **Devuelve:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`) `True` indica que detenemos la generación para una fila en particular. `False` indica que debemos continuar. #### transformers.EosTokenCriteria[[transformers.EosTokenCriteria]] ```python transformers.EosTokenCriteria(eos_token_id: typing.Union[int, list[int], torch.Tensor]) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L537) **Parámetros:** eos_token_id (`Union[int, list[int], torch.Tensor]`) : El o los id del token *end-of-sequence*. Esta clase se puede utilizar para detener la generación en cualquier momento en que se genere el token de "fin de secuencia". De forma predeterminada, utiliza `model.generation_config.eos_token_id`. #### __llamada__[[transformers.EosTokenCriteria.__call__]] ```python __call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, new_token_length: int = 1, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L554) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) scores (`tuple(torch.Tensor)`) : Puntuaciones de predicción de una cabeza de modelado de lenguaje, como una tupla con un tensor por paso de generación, cada uno de forma `(batch_size, config.vocab_size)`. Estas pueden ser puntuaciones para cada token del vocabulario antes de SoftMax o puntuaciones para cada token del vocabulario después de SoftMax. Si este criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`, de lo contrario se pasa `None`. new_token_length (`int`, *opcional*, valor predeterminado `1`) : El número de tokens que se verificarán para los criterios. Se verificarán los últimos `new_token_length` tokens de cada elemento del lote. kwargs (`dict[str, Any]`, *opcional*) : Palabras clave adicionales específicas para los criterios de parada. **Devuelve:** `torch.BoolTensor`. (`torch.BoolTensor` de forma `(batch_size, 1)`) `True` indica que detenemos la generación para una fila en particular. `False` indica que debemos continuar. ## Streamers[[transformers.TextStreamer]] #### transformers.TextStreamer[[transformers.TextStreamer]] ```python transformers.TextStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, **decode_kwargs: Any) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L41) **Parámetros:** tokenizer (`AutoTokenizer`) : El tokenizador utilizado para decodificar los tokens. skip_prompt (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe omitir el prompt para `.generate()` o no. Útil, por ejemplo, para chatbots. decode_kwargs (`dict`, *opcional*) : Argumentos de palabra clave adicionales para pasar al método `decode` del tokenizador. Streamer de texto simple que imprime los tokens en stdout en cuanto se forman palabras completas. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer >>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt") >>> streamer = TextStreamer(tok) >>> # Despite returning the usual output, the streamer will also print the generated text to stdout. >>> _ = model.generate(**inputs, streamer=streamer, max_new_tokens=20) An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven, ``` #### fin[[transformers.TextStreamer.end]] ```python end() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L113) Descarga cualquier caché restante e imprime un salto de línea en la salida estándar. #### on_finalized_text[[transformers.TextStreamer.on_finalized_text]] ```python on_finalized_text(text: str, stream_end: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L127) Imprime el nuevo texto en stdout. Si el flujo está terminando, también imprime un salto de línea. #### put[[transformers.TextStreamer.put]] ```python put(value) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L79) Recibe tokens, los decodifica y los imprime en stdout en cuanto forman palabras completas. #### transformers.TextIteratorStreamer[[transformers.TextIteratorStreamer]] ```python transformers.TextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L156) **Parámetros:** tokenizer (`AutoTokenizer`) : El tokenizador utilizado para decodificar los tokens. skip_prompt (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe omitir el prompt para `.generate()` o no. Útil, por ejemplo, para chatbots. timeout (`float`, *opcional*) : El tiempo de espera para la cola de texto. Si es `None`, la cola bloqueará indefinidamente. Útil para manejar excepciones en `.generate()` cuando se llama en un hilo separado. decode_kwargs (`dict`, *opcional*) : Argumentos de palabra clave adicionales para pasar al método `decode` del tokenizador. Streamer que almacena texto listo para imprimir en una cola, para ser utilizado por una aplicación aguas abajo como un iterador. Esto es útil para aplicaciones que se benefician de acceder al texto generado de manera no bloqueante (p. ej., en una demo interactiva de Gradio). Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer >>> from threading import Thread >>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt") >>> streamer = TextIteratorStreamer(tok) >>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way. >>> generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20) >>> thread = Thread(target=model.generate, kwargs=generation_kwargs) >>> thread.start() >>> generated_text = "" >>> for new_text in streamer: ... generated_text += new_text >>> generated_text 'An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,' ``` #### on_finalized_text[[transformers.TextIteratorStreamer.on_finalized_text]] ```python on_finalized_text(text: str, stream_end: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L208) Coloca el nuevo texto en la cola. Si el flujo está terminando, coloca también una señal de parada en la cola. #### transformers.AsyncTextIteratorStreamer[[transformers.AsyncTextIteratorStreamer]] ```python transformers.AsyncTextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L225) **Parámetros:** tokenizer (`AutoTokenizer`) : El tokenizador utilizado para decodificar los tokens. skip_prompt (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe omitir el prompt para `.generate()` o no. Útil, por ejemplo, para chatbots. timeout (`float`, *opcional*) : El tiempo de espera para la cola de texto. Si es `None`, la cola bloqueará indefinidamente. Útil para manejar excepciones en `.generate()` cuando se llama en un hilo separado. decode_kwargs (`dict`, *opcional*) : Argumentos de palabra clave adicionales para pasar al método `decode` del tokenizador. **Excepciones:** ``TimeoutError`` - ``TimeoutError`` -- Si el tiempo de generación de tokens supera el valor de timeout. Streamer que almacena texto listo para imprimir en una cola, para ser utilizado por una aplicación aguas abajo como un iterador asíncrono. Esto es útil para aplicaciones que se benefician de acceder al texto generado de forma asíncrona (p. ej., en una demo interactiva de Gradio). Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, AsyncTextIteratorStreamer >>> from threading import Thread >>> import asyncio >>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2") >>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2") >>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt") >>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way. >>> async def main(): ... # Important: AsyncTextIteratorStreamer must be initialized inside a coroutine! ... streamer = AsyncTextIteratorStreamer(tok) ... generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20) ... thread = Thread(target=model.generate, kwargs=generation_kwargs) ... thread.start() ... generated_text = "" ... async for new_text in streamer: ... generated_text += new_text >>> print(generated_text) >>> asyncio.run(main()) An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven, ``` #### on_finalized_text[[transformers.AsyncTextIteratorStreamer.on_finalized_text]] ```python on_finalized_text(text: str, stream_end: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L285) Coloca el nuevo texto en la cola. Si el flujo está terminando, coloca también una señal de parada en la cola. #### transformers.TextDiffusionStreamer[[transformers.TextDiffusionStreamer]] ```python transformers.TextDiffusionStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, sleep_time: float | None = None, **decode_kwargs: Any) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L303) **Parámetros:** tokenizer (`AutoTokenizer`) : El tokenizado utilizado para decodificar los tokens. skip_prompt (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe omitir el prompt para `.generate()` o no. Útil, por ejemplo, para chatbots. sleep_time (`float`, *opcional*) : Tiempo de espera entre los borradores de difusión, lo cual puede ser útil para visualizar las salidas intermedias. decode_kwargs (`dict`, *opcional*) : Argumentos de palabra clave adicionales para pasar al método `decode` del tokenizador. Streamer que imprime las salidas de difusión de texto. Los pasos intermedios de difusión (borradores) son temporales y se sobrescriben con los borradores posteriores, y se eliminan cuando se imprime el texto confirmado. Si estás trabajando en un entorno como tmux, es posible que el texto de borrador no se sobrescriba a sí mismo. Ejemplos: ```python >>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer >>> model = DiffusionGemmaForBlockDiffusion.from_pretrained( ... "google/diffusiongemma-26B-A4B-it", device_map="auto", ... ) >>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it") >>> chat = [{"role": "user", "content": "Why is the sky blue?"},] >>> input_ids = processor.apply_chat_template( ... chat, tokenize=True, return_tensors="pt", add_generation_prompt=True ... ) >>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer) >>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer) ``` #### fin[[transformers.TextDiffusionStreamer.end]] ```python end() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L392) Vacía cualquier caché restante e imprime un salto de línea. #### put[[transformers.TextDiffusionStreamer.put]] ```python put(value) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L387) Recibe los tokens confirmados, limpia el borrador y los imprime de forma permanente. #### put_draft[[transformers.TextDiffusionStreamer.put_draft]] ```python put_draft(value, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L365) Recibe la secuencia completa de tokens de borrador, los decodifica y los imprime en amarillo. Sobrescribe el borrador anterior. ## Cachés[[transformers.CacheLayerMixin]] #### transformers.CacheLayerMixin[[transformers.CacheLayerMixin]] ```python transformers.CacheLayerMixin(**kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L23) Base, clase abstracta para la caché de una sola capa. #### actualizar[[transformers.CacheLayerMixin.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L52) #### get_seq_length[[transformers.CacheLayerMixin.get_seq_length]] ```python get_seq_length() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L60) #### get_mask_sizes[[transformers.CacheLayerMixin.get_mask_sizes]] ```python get_mask_sizes(query_length: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L57) #### get_max_length[[transformers.CacheLayerMixin.get_max_length]] ```python get_max_length() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L63) Devuelve la longitud máxima de secuencia que puede contener la capa. Un valor de `-1` significa que no hay un máximo, o que el máximo no está definido, por ejemplo, una capa de atención dinámica que crece indefinidamente o una capa de atención lineal que no tiene una dimensión de longitud de secuencia. #### restablecer[[transformers.CacheLayerMixin.reset]] ```python reset() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L84) Restablece los valores de la caché mientras preserva los objetos #### reorder_cache[[transformers.CacheLayerMixin.reorder_cache]] ```python reorder_cache(beam_idx: LongTensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L97) Reordena la caché de esta capa para la búsqueda por haz. #### lazy_initialization[[transformers.CacheLayerMixin.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L49) #### transformers.DynamicLayer[[transformers.DynamicLayer]] ```python transformers.DynamicLayer(**kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L104) Una capa de caché que crece dinámicamente a medida que se generan más tokens. Este es el comportamiento predeterminado para los modelos generativos. Almacena los estados de clave y valor como tensores de forma `[batch_size, num_heads, seq_len, head_dim]`. #### actualizar[[transformers.DynamicLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L119) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. **Devuelve:** tuple[`torch.Tensor`, `torch.Tensor`] Los estados de clave y valor. Actualice las cachés de claves y valores in-place y devuelva los estados de claves y valores necesarios. #### lazy_initialization[[transformers.DynamicLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113) #### crop[[transformers.DynamicLayer.crop]] ```python crop(tokens_to_remove: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L164) Elimina los tokens `tokens_to_remove` de la capa de caché actual. #### batch_repeat_interleave[[transformers.DynamicLayer.batch_repeat_interleave]] ```python batch_repeat_interleave(repeats: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L183) Repite la caché `repeats` veces en la dimensión del lote. #### batch_select_indices[[transformers.DynamicLayer.batch_select_indices]] ```python batch_select_indices(indices: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L189) Conserva solo los `indices` en la dimensión del lote de la caché. #### transformers.StaticLayer[[transformers.StaticLayer]] ```python transformers.StaticLayer(max_cache_len: int, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L403) **Parámetros:** max_cache_len (`int`) : Número máximo de tokens que se pueden almacenar, utilizado para la preasignación de tensores. Una capa de caché estática que almacena los estados de clave y valor como tensores estáticos de forma `[batch_size, num_heads, max_cache_len, head_dim]`. Asigna de forma perezosa sus tensores de respaldo completos y luego los modifica in situ. Diseñada para admitir `torch.compile`. #### actualizar[[transformers.StaticLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L461) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. **Devuelve:** tuple[`torch.Tensor`, `torch.Tensor`] Los estados de clave y valor. Actualice las cachés de claves y valores in-place y devuelva los estados de claves y valores necesarios. #### lazy_initialization[[transformers.StaticLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423) Inicialización diferida de los tensores de claves y valores. Esto permite obtener todas las propiedades (dtype, device, num_heads en caso de TP, etc.) directamente en tiempo de ejecución, lo cual es extremadamente práctico, ya que evita mover dispositivos, dtypes, etc. más adelante para cada `update` (lo que también podría romper las direcciones estáticas de dynamo). Si no se desea este comportamiento, se puede llamar a `early_initialization(...)` directamente en la Cache, lo que invocará esta función de antemano (esto es necesario, por ejemplo, para `torch.export`). También es obligatorio siempre que el prefill en sí termine en una región compilada (por ejemplo, con prefill por bloques). #### transformers.StaticSlidingWindowLayer[[transformers.StaticSlidingWindowLayer]] ```python transformers.StaticSlidingWindowLayer(max_cache_len: int, sliding_window: int, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L510) **Parámetros:** max_cache_len (`int`) : Número máximo de tokens que se pueden almacenar, utilizado para la preasignación de tensores. sliding_window (`int`) : El tamaño de la ventana deslizante. Una capa de caché estática que almacena los estados de clave y valor como tensores estáticos de forma `[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]`. Asigna de forma perezosa sus tensores de respaldo completos y luego los modifica in situ. Diseñada para admitir `torch.compile`. #### actualizar[[transformers.StaticSlidingWindowLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L531) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. **Devuelve:** tuple[`torch.Tensor`, `torch.Tensor`] Los estados de clave y valor. Actualice las cachés de claves y valores in-place y devuelva los estados de claves y valores necesarios. #### lazy_initialization[[transformers.StaticSlidingWindowLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423) Inicialización diferida de los tensores de claves y valores. Esto permite obtener todas las propiedades (dtype, device, num_heads en caso de TP, etc.) directamente en tiempo de ejecución, lo cual es extremadamente práctico, ya que evita mover dispositivos, dtypes, etc. más adelante para cada `update` (lo que también podría romper las direcciones estáticas de dynamo). Si no se desea este comportamiento, se puede llamar a `early_initialization(...)` directamente en la Cache, lo que invocará esta función de antemano (esto es necesario, por ejemplo, para `torch.export`). También es obligatorio siempre que el prefill en sí termine en una región compilada (por ejemplo, con prefill por bloques). #### transformers.QuantoQuantizedLayer[[transformers.QuantoQuantizedLayer]] ```python transformers.QuantoQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L854) #### actualizar[[transformers.QuantoQuantizedLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. **Devuelve:** tuple[`torch.Tensor`, `torch.Tensor`] Los estados de clave y valor. Actualice las cachés de claves y valores in-place y devuelva los estados de claves y valores necesarios. #### lazy_initialization[[transformers.QuantoQuantizedLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113) #### transformers.HQQQuantizedLayer[[transformers.HQQQuantizedLayer]] ```python transformers.HQQQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L909) #### actualizar[[transformers.HQQQuantizedLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. **Devuelve:** tuple[`torch.Tensor`, `torch.Tensor`] Los estados de clave y valor. Actualice las cachés de claves y valores in-place y devuelva los estados de claves y valores necesarios. #### lazy_initialization[[transformers.HQQQuantizedLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113) #### transformers.Fp8QuantizedLayer[[transformers.Fp8QuantizedLayer]] ```python transformers.Fp8QuantizedLayer() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L966) Una capa cuantizada que almacena los estados de clave y valor en punto flotante de 8 bits. La escala por tensor se congela después de la primera `update`, por lo que los nuevos estados se agregan tal cual: sin caché residual y sin recuantización. Una variante de mayor granularidad corresponde aquí y no bajo `QuantizedLayer`, ya que agrupar a lo largo de la dimensión de cabeceras mantiene los estados apendibles y solo convierte la escala almacenada en un tensor. #### actualizar[[transformers.Fp8QuantizedLayer.update]] ```python update(key_states: Tensor, value_states: Tensor, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L994) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. **Devuelve:** tuple[`torch.Tensor`, `torch.Tensor`] Los estados de clave y valor. Actualice las cachés de claves y valores in-place y devuelva los estados de claves y valores necesarios. #### lazy_initialization[[transformers.Fp8QuantizedLayer.lazy_initialization]] ```python lazy_initialization(key_states: Tensor, value_states: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L978) #### transformers.Cache[[transformers.Cache]] ```python transformers.Cache(layers: list[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin | transformers.cache_utils.DummyLayer] | None = None, layer_class_to_replicate: type[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin] | None = None, offloading: bool = False, offload_only_non_sliding: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1453) **Parámetros:** layers (`Optional`, *opcional*) : Una lista de `CacheLayerMixin` o `LinearAttentionCacheLayerMixin` precreados. Si se omite (`None`), se utilizará `layer_class_to_replicate`. layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`, *opcional*) : Solo se utiliza si se omite `layers` (`None`), en cuyo caso se usará como clase base para cada capa, y las capas se añadirán de forma perezosa en cuanto se llame a `update` con un `layer_idx` mayor que la lista actual de capas. offloading (`bool`, *opcional*, valor predeterminado `False`) : Si se realiza el descargado de las capas a `cpu` para ahorrar memoria de GPU. offload_only_non_sliding (`bool`, *opcional*, valor predeterminado `True`) : Si `offloading` es `True`, este parámetro determina si solo se descargan las capas no deslizantes (ya que las capas deslizantes suelen ser pequeñas en tamaño, por lo que no es necesario descargarlas y omitir este proceso es más rápido). Un `Cache` es principalmente una lista de objetos `CacheLayerMixin`, uno por cada capa del modelo. Sirve como contenedor del Cache de cada capa. #### actualizar[[transformers.Cache.update]] ```python update(key_states: Tensor, value_states: Tensor, layer_idx: int, *args, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1540) **Parámetros:** key_states (`torch.Tensor`) : Los nuevos estados clave para cachear. value_states (`torch.Tensor`) : Los nuevos valores de estado a cachear. layer_idx (`int`) : El índice de la capa para la que se deben cachear los estados. **Devuelve:** Una tupla que contiene los estados actualizados de las claves y los valores. Actualiza la caché con los nuevos `key_states` y `value_states` para la capa `layer_idx`. #### early_initialization[[transformers.Cache.early_initialization]] ```python early_initialization(batch_size: int, num_heads: int | list[int], head_dim: int | list[int], dtype: dtype, device: device) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1669) Inicializa todas las capas de antemano (de lo contrario, se inicializan de forma perezosa en la primera llamada a `update`). Esto es útil para nuestras recetas de `export`, ya que `export` necesita todo de antemano. #### get_seq_length[[transformers.Cache.get_seq_length]] ```python get_seq_length(layer_idx: int = 0) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1706) Devuelve la longitud de la secuencia de la caché para la capa indicada. #### get_mask_sizes[[transformers.Cache.get_mask_sizes]] ```python get_mask_sizes(query_length: int, layer_idx: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1776) Devuelve una tupla (kv_length, kv_offset) que corresponde a la longitud y el desplazamiento que se devolverán para la capa dada en `layer_idx`. A continuación, las máscaras se preparan según las longitudes (kv_length, kv_offset) y los patrones de cada capa. #### get_max_length[[transformers.Cache.get_max_length]] ```python get_max_length(layer_idx: int | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1730) Devuelve la longitud máxima de la caché. Si no se proporciona `layer_idx` (valor predeterminado), devuelve el máximo entre todas las capas. En caso contrario, devuelve el valor máximo admitido para la capa indicada. Un valor de `-1` significa que no hay un máximo, o que el máximo no está definido, por ejemplo, para capas de atención dinámica que pueden crecer indefinidamente, o capas de atención lineal que no tienen una dimensión de longitud de secuencia. #### restablecer[[transformers.Cache.reset]] ```python reset() ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1813) Restablecer recursivamente los tensores de todas las capas #### reorder_cache[[transformers.Cache.reorder_cache]] ```python reorder_cache(beam_idx: LongTensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1818) Reordenar la caché para la búsqueda por haz #### crop[[transformers.Cache.crop]] ```python crop(tokens_to_remove: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1823) Elimina los tokens `tokens_to_remove` de la Cache actual. Para las capas que no necesitan mantener todos los estados pasados en memoria, como las capas de ventana deslizante o las capas de atención lineal, esto también limitará el tamaño de los estados en caché a su tamaño de trabajo mínimo. Esto significa que `crop(0)` no será necesariamente una operación sin efecto, ya que aún puede eliminar estados innecesarios (es decir, estados que no se necesitan para el siguiente `forward`) de la Cache. #### batch_repeat_interleave[[transformers.Cache.batch_repeat_interleave]] ```python batch_repeat_interleave(repeats: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1833) Repetir e intercalar la caché #### batch_select_indices[[transformers.Cache.batch_select_indices]] ```python batch_select_indices(indices: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1838) Seleccionar índices de la caché #### transformers.DynamicCache[[transformers.DynamicCache]] ```python transformers.DynamicCache(ddp_cache_data: collections.abc.Iterable[tuple[typing.Optional[torch.Tensor], ...]] | None = None, config: transformers.configuration_utils.PreTrainedConfig | None = None, offloading: bool = False, offload_only_non_sliding: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1960) **Parámetros:** ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`, *opcional*) : Se añadió originalmente para compatibilidad con `torch.distributed` (DDP). En resumen, es `map(gather_map, zip(*caches))`, es decir, cada elemento del iterable contiene los estados de clave y valor para una capa, reunidos entre réplicas por torch.distributed (shape=[global batch size, num_heads, seq_len, head_dim]). Nota: también debe ser el 1.er argumento para que funcione correctamente config (`PreTrainedConfig`, *opcional*) : La configuración del modelo para el que se utilizará esta Cache. Si se proporciona, se usará para verificar la estructura de capas deslizantes o híbridas, reduciendo en gran medida el requisito de memoria de los tensores en caché a `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`. offloading (`bool`, *opcional*, valor predeterminado `False`) : Si se realiza el descargado de las capas a `cpu` para ahorrar memoria de GPU. offload_only_non_sliding (`bool`, *opcional*, valor predeterminado `False`) : Si `offloading` es `True`, este parámetro determina además si solo se descargan las capas no deslizantes (ya que normalmente las capas deslizantes son pequeñas en tamaño, por lo que no es necesario descargarlas y omitirlo es más rápido). Una caché que crece dinámicamente a medida que se generan más tokens. Este es el comportamiento predeterminado para los modelos generativos. Almacena los estados de clave y valor como una lista de `CacheLayer`, uno por cada capa. La forma esperada para cada tensor en los `CacheLayer` es `[batch_size, num_heads, seq_len, head_dim]`. Si se pasa una configuración, también se comprueba si la estructura de la caché es deslizante o híbrida, lo que reduce considerablemente el requisito de memoria de los tensores en caché a `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`. Consulte `Cache` para obtener detalles sobre los métodos comunes que implementan todas las clases de caché. Ejemplo: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, DynamicCache >>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct") >>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct") >>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt") >>> # Prepare a cache class and pass it to model's forward >>> past_key_values = DynamicCache(config=model.config) >>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True) >>> outputs.past_key_values # access cache filled with key/values from generation ``` #### transformers.StaticCache[[transformers.StaticCache]] ```python transformers.StaticCache(config: PreTrainedConfig, max_cache_len: int, offloading: bool = False, offload_only_non_sliding: bool = True, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2056) **Parámetros:** config (`PreTrainedConfig`): La configuración del modelo para el que se utilizará esta Cache. Se usará para verificar la estructura de capas deslizantes o híbridas e inicializar cada capa en consecuencia. max_cache_len (`int`) : El número máximo de tokens que esta Cache debe contener. offloading (`bool`, *opcional*, valor predeterminado `False`) : Si se realiza el descargado de las capas a `cpu` para ahorrar memoria de GPU. offload_only_non_sliding (`bool`, *opcional*, valor predeterminado `True`) : Si `offloading` es `True`, este parámetro determina si solo se descargan las capas no deslizantes (ya que las capas deslizantes suelen ser pequeñas en tamaño, por lo que no es necesario descargarlas y omitir este proceso es más rápido). Clase de caché estática para usar con `torch.compile(model)` y `torch.export()`. Revisará la `config` en busca de una posible estructura de caché híbrida e inicializará cada capa en consecuencia. Consulte `Cache` para obtener detalles sobre los métodos comunes que implementan todas las clases de caché. Ejemplo: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, StaticCache >>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf") >>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf") >>> inputs = tokenizer(text="My name is Llama", return_tensors="pt") >>> # Prepare a cache class and pass it to model's forward >>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate >>> max_generated_length = inputs.input_ids.shape[1] + 10 >>> past_key_values = StaticCache(config=model.config, max_cache_len=max_generated_length) >>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True) >>> outputs.past_key_values # access cache filled with key/values from generation StaticCache() ``` #### transformers.QuantizedCache[[transformers.QuantizedCache]] ```python transformers.QuantizedCache(backend: str, config: PreTrainedConfig, nbits: int | None = None, axis_key: int | None = None, axis_value: int | None = None, q_group_size: int | None = None, residual_length: int | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2113) **Parámetros:** backend (`str`) : El backend de cuantización a utilizar. Uno de `("quanto", "hqq", "fp8")`. config (`PreTrainedConfig`) : La configuración del modelo para el que se utilizará esta Cache. nbits (`int`, *opcional*, valor predeterminado: 4) : El número de bits para la cuantización. axis_key (`int`, *opcional*, valor predeterminado 0) : El eje sobre el que cuantizar las claves. axis_value (`int`, *opcional*, valor predeterminado 0) : El eje sobre el que se cuantizan los valores. q_group_size (`int`, *opcional*, valor predeterminado: 64) : La cuantización se realiza por canal según un conjunto `q_group_size` para ambas claves y valores. residual_length (`int`, *opcional*, valor predeterminado 128) : Capacidad máxima para la caché de precisión original. Un caché de cuantización similar al descrito en el [artículo KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache](https://huggingface.co/papers/2402.02750). Permite que el modelo genere secuencias de mayor longitud sin asignar demasiada memoria para las claves y los valores, aplicando cuantización. El caché tiene dos tipos de almacenamiento, uno para la precisión original y otro para el caché cuantizado. Se establece una `residual length` como capacidad máxima para el caché de precisión original. Cuando la longitud supera la capacidad máxima, el caché de precisión original se descarta y se transfiere al caché cuantizado. La cuantización se realiza por canal con un `q_group_size` establecido para ambas claves y valores, a diferencia de lo descrito en el artículo. Consulte `Cache` para obtener detalles sobre los métodos comunes que implementan todas las clases de caché. Los últimos cinco argumentos configuran los backends de enteros por grupo. El backend `fp8` cuantiza por tensor y los rechaza. #### transformers.EncoderDecoderCache[[transformers.EncoderDecoderCache]] ```python transformers.EncoderDecoderCache(*caches) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2199) **Parámetros:** caches (`Iterable`) : Normalmente, un iterable de longitud 2 que contiene 2 objetos `Cache`, el primero para la autoatención y el segundo para la atención cruzada. Opcionalmente, también puede ser un iterable de longitud 1 que contiene una `tuple[tuple[torch.Tensor]]` (se usa habitualmente para compatibilidad con torch dp y ddp). Clase base y abstracta para todas las cachés de codificador-decodificador. Puede usarse para contener combinaciones de cachés de autoatención y atención cruzada. Consulte `Cache` para obtener detalles sobre los métodos comunes que implementan todas las clases de caché. Ejemplo: ```python >>> from transformers import AutoProcessor, AutoModelForCausalLM, DynamicCache, EncoderDecoderCache >>> model = AutoModelForCausalLM.from_pretrained("openai/whisper-small") >>> processor = AutoProcessor.from_pretrained("openai/whisper-small") >>> inputs = processor(audio=YOUR-AUDIO, return_tensors="pt") >>> # Prepare cache classes for encoder and decoder and pass it to model's forward >>> self_attention_cache = DynamicCache(config=self.config) >>> cross_attention_cache = DynamicCache(config=self.config) >>> past_key_values = EncoderDecoderCache(self_attention_cache, cross_attention_cache) >>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True) >>> outputs.past_key_values # access cache filled with key/values from generation EncoderDecoderCache() ``` #### batch_repeat_interleave[[transformers.EncoderDecoderCache.batch_repeat_interleave]] ```python batch_repeat_interleave(repeats: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2316) Repite la caché `repeats` veces en la dimensión del lote. Se utiliza en la búsqueda contrastiva (en el Hub). #### batch_select_indices[[transformers.EncoderDecoderCache.batch_select_indices]] ```python batch_select_indices(indices: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2322) Conserva solo los `indices` en la dimensión del lote de la caché. Se utiliza en la búsqueda contrastiva (en el Hub). #### crop[[transformers.EncoderDecoderCache.crop]] ```python crop(tokens_to_remove: int) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2309) Elimina los tokens `tokens_to_remove` de la capa de caché actual. #### get_max_length[[transformers.EncoderDecoderCache.get_max_length]] ```python get_max_length(layer_idx: int | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2284) Devuelve la longitud máxima de la secuencia (es decir, la capacidad máxima) del objeto de caché #### get_seq_length[[transformers.EncoderDecoderCache.get_seq_length]] ```python get_seq_length(layer_idx: int = 0) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2280) Devuelve la longitud de la secuencia de los estados en caché. Se puede pasar opcionalmente un índice de capa. #### reorder_cache[[transformers.EncoderDecoderCache.reorder_cache]] ```python reorder_cache(beam_idx: LongTensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2294) Reordena la caché para la búsqueda por haces, dados los índices de los haces seleccionados. ## Utilidades de marca de agua[[transformers.WatermarkingConfig]] #### transformers.WatermarkingConfig[[transformers.WatermarkingConfig]] ```python transformers.WatermarkingConfig(greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1458) Clase que contiene los argumentos para la generación de marcas de agua y que debe pasarse a `GenerationConfig` durante `generate`. Consulte [este artículo](https://huggingface.co/papers/2306.04634) para obtener más detalles sobre los argumentos. Acepta las siguientes claves: - greenlist_ratio (`float`): Se utiliza para la marca de agua. La proporción de tokens "verdes" utilizados en relación con el tamaño del vocabulario. El valor predeterminado es 0.25. - bias (`float`): Se utiliza con el marcado de agua. Es el sesgo que se suma a los logits de los tokens "verdes" seleccionados. El valor predeterminado es 2.0. - hashing_key (`int`): Clave de hash utilizada para la marca de agua. El valor predeterminado es 15485863 (el millón primo). - seeding_scheme (`str`): Algoritmo a utilizar para la marca de agua. Acepta los valores: - "lefthash" (predeterminado): la selección de tokens "green" depende del último token (Algoritmo 2 del artículo) - La selección de tokens "selfhash": "green" depende del propio token actual (Algoritmo 3 del artículo). La desventaja de este esquema es que considera todos los tokens siguientes posibles y puede ser más lento que "lefthash". - context_width(`int`): La longitud de contexto de los tokens anteriores que se utilizará en la siembra. Una longitud de contexto mayor hace que el marcaje de agua sea más robusto. #### __llamada__[[transformers.WatermarkingConfig.__call__]] ```python __call__(*args, **kwargs) ``` Llamar a self como una función. #### transformers.WatermarkDetector[[transformers.WatermarkDetector]] ```python transformers.WatermarkDetector(model_config: PreTrainedConfig, device: str, watermarking_config: typing.Union[ForwardRef('WatermarkingConfig'), dict], ignore_repeated_ngrams: bool = False, max_cache_size: int = 128) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L71) **Parámetros:** model_config (`PreTrainedConfig`): La configuración del modelo que se utilizará para obtener los argumentos específicos del modelo empleados durante la generación. device (`str`) : El dispositivo que se utilizó durante la generación de texto con marca de agua. watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : La configuración y los argumentos de marca de agua exactos utilizados al generar texto. ignore_repeated_ngrams (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe contar cada ngrama único solo una vez o no. max_cache_size (`int`, *opcional*, valor predeterminado 128) : El tamaño máximo que se usará para la caché LRU de los algoritmos de siembra/muestreo llamados para cada token. Detector para la detección de texto generado con marca de agua. El detector debe recibir exactamente la misma configuración que se proporcionó durante la generación del texto para replicar la generación de la lista verde de la marca de agua y, así, detectar la marca de agua. Esto incluye el dispositivo correcto utilizado durante la generación del texto, los argumentos correctos de marca de agua y el tamaño correcto del vocabulario del tokenizador. El código se basó en el [repositorio original](https://github.com/jwkirchenbauer/lm-watermarking/tree/main). Consulte [el artículo](https://huggingface.co/papers/2306.04634) para obtener más información. Ejemplos: ```python >>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig >>> model_id = "openai-community/gpt2" >>> model = AutoModelForCausalLM.from_pretrained(model_id) >>> tok = AutoTokenizer.from_pretrained(model_id) >>> tok.pad_token_id = tok.eos_token_id >>> tok.padding_side = "left" >>> inputs = tok(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt") >>> input_len = inputs["input_ids"].shape[-1] >>> # first generate text with watermark and without >>> watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash") >>> out_watermarked = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20) >>> out = model.generate(**inputs, do_sample=False, max_length=20) >>> # now we can instantiate the detector and check the generated text >>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config) >>> detection_out_watermarked = detector(out_watermarked, return_dict=True) >>> detection_out = detector(out, return_dict=True) >>> detection_out_watermarked.prediction array([ True, True]) >>> detection_out.prediction array([False, False]) ``` #### __llamada__[[transformers.WatermarkDetector.__call__]] ```python __call__(input_ids: LongTensor, z_threshold: float = 3.0, return_dict: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L193) **Parámetros:** input_ids (`torch.LongTensor`) : El texto generado con marca de agua. Se recomienda eliminar el prompt, ya que puede afectar la detección. z_threshold (`Dict`, *opcional*, valor predeterminado `3.0`) : Cambiar este umbral modificará la sensibilidad del detector. Un umbral z más alto proporciona menor sensibilidad y viceversa para un umbral z más bajo. return_dict (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver `~generation.WatermarkDetectorOutput` o no. En caso contrario, se devolverán predicciones booleanas, **Devuelve:** `WatermarkDetectorOutput` o `np.ndarray` Un `WatermarkDetectorOutput` si `return_dict=True`, de lo contrario un `np.ndarray`. ma #### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]] ```python transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L252) **Parámetros:** watermarking_depth (`int`, *opcional*) : El número de capas de torneo. base_rate (`float`, *opcional*, valor predeterminado 0.5) : Probabilidad a priori P(w) de que un texto esté marcado con marca de agua. Esta es la clase de configuración para almacenar la configuración de un [BayesianDetectorModel](/docs/transformers/main/es/internal/generation_utils#transformers.BayesianDetectorModel). Se utiliza para instanciar un modelo Bayesian Detector según los argumentos especificados. Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. #### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]] ```python transformers.BayesianDetectorModel(config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L359) **Parámetros:** config ([BayesianDetectorConfig](/docs/transformers/main/es/internal/generation_utils#transformers.BayesianDetectorConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. Clasificador bayesiano para la detección de marcas de agua. Este detector utiliza la regla de Bayes para calcular una puntuación de marca de agua, que es la sigmoide del logaritmo de la razón entre las probabilidades a posteriori P(watermarked|g_values) y P(unwatermarked|g_values). Consulte la sección sobre BayesianScore en el artículo para obtener más detalles. URL del artículo: https://www.nature.com/articles/s41586-024-08025-4 Tenga en cuenta que este detector solo funciona con marcas de agua basadas en torneos no distorsionantes que utilizan la distribución de valores g de Bernoulli(0.5). Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.). Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales. #### forward[[transformers.BayesianDetectorModel.forward]] ```python forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L448) **Parámetros:** g_values (`torch.Tensor` de forma `(batch_size, seq_len, watermarking_depth, ...)`) : valores g (con valores 0 o 1) mask : Un array binario de forma [batch_size, seq_len] que indica qué valores de g deben usarse. Los valores de g con valor de máscara 0 se descartan. **Devuelve:** p(watermarked | g_values), de forma [batch_size]. Calcula la posterior con marca de agua P(watermarked|g_values). #### transformers.SynthIDTextWatermarkingConfig[[transformers.SynthIDTextWatermarkingConfig]] ```python transformers.SynthIDTextWatermarkingConfig(ngram_len: int, keys: list, context_history_size: int = 1024, sampling_table_seed: int = 0, sampling_table_size: int = 65536, skip_first_ngram_calls: bool = False, debug_mode: bool = False) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1538) **Parámetros:** ngram_len (`int`) : Longitud del n-grama. keys (`list[int]`) : Una secuencia de claves de marca de agua, una para cada profundidad. context_history_size (`int`, *opcional*, valor predeterminado 1024) : Tamaño del tensor para llevar un registro de los contextos vistos. sampling_table_seed (`int`, *opcional*, valor predeterminado 0) : Semilla aleatoria para generar la tabla de muestreo. sampling_table_size (`int`, *opcional*, valor predeterminado 65536) : Tamaño de la tabla de muestreo. skip_first_ngram_calls (`bool`, *opcional*, valor predeterminado `False`) : Si se deben omitir las primeras llamadas a ngram. debug_mode (`bool`, *opcional*, valor predeterminado `False`) : Los logits se modifican a uno uniforme antes de que se aplique la modificación del marca de agua. Esto sirve para probar la implementación. Clase que contiene los argumentos para la generación de marcas de agua y que debe pasarse a `GenerationConfig` durante `generate`. Consulte [este artículo](https://www.nature.com/articles/s41586-024-08025-4) para obtener más detalles sobre los argumentos. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig >>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left") >>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b') >>> # SynthID Text configuration >>> watermarking_config = SynthIDTextWatermarkingConfig( ... keys=[654, 400, 836, 123, 340, 443, 597, 160, 57], ... ngram_len=5, ... ) >>> # Generation with watermarking >>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True) >>> output_sequences = model.generate( ... **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10 ... ) >>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True) ``` #### transformers.SynthIDTextWatermarkDetector[[transformers.SynthIDTextWatermarkDetector]] ```python transformers.SynthIDTextWatermarkDetector(detector_module: BayesianDetectorModel, logits_processor: SynthIDTextWatermarkLogitsProcessor, tokenizer: Any) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L492) **Parámetros:** detector_module ([BayesianDetectorModel](/docs/transformers/main/es/internal/generation_utils#transformers.BayesianDetectorModel)) : objeto de módulo de detector bayesiano inicializado con parámetros. Consulte https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text para ver su uso. logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : el procesador de logits utilizado para la marca de agua. tokenizer (`Any`) : El tokenizador utilizado para el modelo. Clase del detector de marca de agua de texto SynthID. Esta clase debe inicializarse con el módulo de detector bayesiano entrenado; consulte el script de verificación en examples/synthid_text/detector_training.py como ejemplo de entrenamiento, guardado y carga de este módulo de detector. La carpeta también muestra un caso de uso de ejemplo de este detector. Ejemplos: ```python >>> from transformers import ( ... AutoTokenizer, BayesianDetectorModel, SynthIDTextWatermarkLogitsProcessor, SynthIDTextWatermarkDetector ... ) >>> # Load the detector. See https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text for training a detector. >>> detector_model = BayesianDetectorModel.from_pretrained("joaogante/dummy_synthid_detector") >>> logits_processor = SynthIDTextWatermarkLogitsProcessor( ... **detector_model.config.watermarking_config, device="cpu" ... ) >>> tokenizer = AutoTokenizer.from_pretrained(detector_model.config.model_name) >>> detector = SynthIDTextWatermarkDetector(detector_model, logits_processor, tokenizer) >>> # Test whether a certain string is watermarked >>> test_input = tokenizer(["This is a test input"], return_tensors="pt") >>> is_watermarked = detector(test_input.input_ids) ``` #### __llamada__[[transformers.SynthIDTextWatermarkDetector.__call__]] ```python __call__(tokenized_outputs: Tensor) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L539) ## Utilidades de compilación[[transformers.CompileConfig]] #### transformers.CompileConfig[[transformers.CompileConfig]] ```python transformers.CompileConfig(fullgraph: bool = False, dynamic: bool | None = None, backend: str | collections.abc.Callable = 'inductor', mode: str = 'reduce-overhead', options: dict | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1630) **Parámetros:** fullgraph (`bool`, *opcional*, valor predeterminado `False`) : Si es False (predeterminado), intenta descubrir regiones compilables que se optimizarán. Si es True, se requiere que la función completa pueda capturarse en un único grafo. Si esto no es posible (es decir, si hay interrupciones en el grafo), se generará un error. dynamic (`bool` o `None`, *opcional*) : Si se debe intentar usar grafos de forma dinámica. backend (`str` o `Callable`, *opcional*, valor predeterminado `"inductor"`) : Backend que se utilizará. mode (`str`, *opcional*, valor predeterminado `"reduce-overhead"`) : Controla el equilibrio entre el rendimiento y la sobrecarga. options (`dict`, *opcional*) : Un diccionario de opciones para pasar al backend. Clase que contiene los argumentos relativos al comportamiento de `torch.compile` al usar la compilación automática en `generate`. Consulte [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html) para obtener más detalles sobre los argumentos. Ejemplos: ```python >>> from transformers import AutoModelForCausalLM, AutoTokenizer, CompileConfig >>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b') >>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b').cuda() >>> # Automatic compile configuration, used with static cache >>> compile_config = CompileConfig(dynamic=True) >>> # Generation with static cache and compile config >>> input = tokenizer.encode("Hello there, how", return_tensors="pt").cuda() >>> output = model.generate( ... input, do_sample=False, max_new_tokens=300, cache_implementation="static", compile_config=compile_config ... ) >>> output_text = tokenizer.batch_decode(output, skip_special_tokens=True)[0] ``` #### __llamada__[[transformers.CompileConfig.__call__]] ```python __call__(*args, **kwargs) ``` Llamar a self como una función.