# Утилиты для генерации

На этой странице перечислены все вспомогательные функции, используемые в [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate).

## Генерация результатов[[transformers.generation.GenerateDecoderOnlyOutput]]

Результатом [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate) является экземпляр подкласса [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput). Этот вывод представляет собой структуру данных, содержащую всю информацию, возвращаемую [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate), но его также можно использовать как кортеж или словарь.

Вот пример:

```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)
```

Объект `generation_output` является [GenerateDecoderOnlyOutput](/docs/transformers/main/ru/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput), и, как видно из документации этого класса ниже, он имеет следующие атрибуты:

- `sequences`: сгенерированные последовательности токенов
- `scores` (необязательный): оценки предсказаний языковой модели для каждого шага генерации
- `hidden_states` (необязательный): скрытые состояния модели для каждого шага генерации
- `attentions` (необязательный): веса внимания модели для каждого шага генерации

Здесь у нас есть `scores`, так как мы передали `output_scores=True`, но нет `hidden_states` и `attentions`, поскольку мы не передавали `output_hidden_states=True` или `output_attentions=True`.

Вы можете обращаться к каждому атрибуту в обычном порядке, и если этот атрибут не был возвращен моделью, вы получите `None`. Например, `generation_output.scores` — это все сгенерированные оценки предсказаний языковой модели, а `generation_output.attentions` равно `None`.

При использовании объекта `generation_output` в виде кортежа сохраняются только атрибуты, значения которых не равны `None`. В данном случае, например, он содержит два элемента: `loss` и `logits`, поэтому

```python
generation_output[:2]
```

например, вернёт кортеж `(generation_output.sequences, generation_output.scores)`.

При использовании объекта `generation_output` как словаря в нём сохраняются только атрибуты, значения которых не равны `None`. В данном случае, например, у него два ключа: `sequences` и `scores`.

Здесь мы описываем все типы выходных данных.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L183)

**Параметры:**

sequences (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Сгенерированные последовательности. Вторая размерность (sequence_length) равна `max_length` или короче, если все батчи завершились досрочно из-за `eos_token_id`.

scores (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_scores=True`) : Обработанные оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax) на каждом шаге генерации. Кортеж из `torch.Tensor` с количеством элементов до `max_new_tokens` (по одному элементу на каждый сгенерированный токен), где каждая тензор имеет форму `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_logits=True`) : Необработанные оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax) на каждом шаге генерации. Кортеж из `torch.Tensor` с количеством элементов не более `max_new_tokens` (по одному элементу на каждый сгенерированный токен), где каждый тензор имеет форму `(batch_size, config.vocab_size)`.

attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) из `torch.Tensor` формы `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_hidden_states=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) из `torch.Tensor` формы `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *необязательный*, возвращается при `use_cache=True`) : Возвращает кэш модели, используемый для ускорения декодирования. У разных моделей разный формат кэша, см. документацию модели. Обычно это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache).

Выводы моделей генерации только с декодером при использовании методов, отличных от beam search.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L219)

**Параметры:**

sequences (`torch.LongTensor` формы `(batch_size*num_return_sequences, sequence_length)`) : Сгенерированные последовательности. Вторая размерность (sequence_length) равна `max_length` или короче, если все батчи завершились досрочно из-за `eos_token_id`.

scores (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_scores=True`) : Обработанные оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax) на каждом шаге генерации. Кортеж из `torch.Tensor` с количеством элементов до `max_new_tokens` (по одному элементу на каждый сгенерированный токен), где каждая тензор имеет форму `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_logits=True`) : Необработанные оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax) на каждом шаге генерации. Кортеж из `torch.Tensor` с количеством элементов не более `max_new_tokens` (по одному элементу на каждый сгенерированный токен), где каждый тензор имеет форму `(batch_size, config.vocab_size)`.

encoder_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя декодера) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода эмбеддингов + один для вывода каждого слоя) с формой `(batch_size, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) из `torch.Tensor` формы `(batch_size, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) из `torch.Tensor` формы `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_hidden_states=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) из `torch.Tensor` формы `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *необязательный*, возвращается при `use_cache=True`) : Возвращает кэш модели, используемый для ускорения декодирования. У разных моделей разный формат кэша, см. документацию модели. Обычно это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache).

Выходы моделей генерации с архитектурой «кодировщик-декодировщик» при использовании методов, отличных от beam search.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L267)

**Параметры:**

sequences (`torch.LongTensor` формы `(batch_size*num_return_sequences, sequence_length)`) : Сгенерированные последовательности. Вторая размерность (sequence_length) равна `max_length` или короче, если все батчи завершились досрочно из-за `eos_token_id`.

sequences_scores (`torch.Tensor` формы `(batch_size*num_return_sequences)`, *необязательный*, возвращается, если `output_scores=True`) : Итоговые оценки лучей для сгенерированных `sequences`.

scores (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_scores=True`) : Оценки переходов лучей для каждого токена словаря на каждом шаге генерации. Оценки переходов лучей, состоящие из логарифмических вероятностей токенов, обусловленных лог-softmax ранее сгенерированных токенов в этом луче. Кортеж `torch.Tensor` с количеством элементов до `max_new_tokens` (один элемент для каждого сгенерированного токена), где каждая тензор имеет форму `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_logits=True`) : Необработанные оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax) на каждом шаге генерации. Кортеж из `torch.Tensor` с количеством элементов не более `max_new_tokens` (по одному элементу на каждый сгенерированный токен), где каждый тензор имеет форму `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *необязательный*, возвращается при `output_scores=True`) : Индексы лучей для сгенерированного идентификатора токена на каждом шаге генерации. `torch.LongTensor` формы `(batch_size*num_return_sequences, sequence_length)`.

attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, когда `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) `torch.Tensor` формы `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, когда `output_hidden_states=True`) : Кортеж (по одному элементу для каждого сгенерированного токена) кортежей (по одному элементу для каждого слоя декодера) `torch.Tensor` формы `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *необязательный*, возвращается при `use_cache=True`) : Возвращает кэш модели, используемый для ускорения декодирования. У разных моделей разный формат кэша, см. документацию модели. Обычно это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache).

Выводы моделей генерации только с декодером при использовании методов лучевого поиска.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L311)

**Параметры:**

sequences (`torch.LongTensor` формы `(batch_size*num_return_sequences, sequence_length)`) : Сгенерированные последовательности. Вторая размерность (sequence_length) равна `max_length` или короче, если все батчи завершились досрочно из-за `eos_token_id`.

sequences_scores (`torch.Tensor` формы `(batch_size*num_return_sequences)`, *необязательный*, возвращается, если `output_scores=True`) : Итоговые оценки лучей для сгенерированных `sequences`.

scores (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_scores=True`) : Оценки переходов лучей для каждого токена словаря на каждом шаге генерации. Оценки переходов лучей, состоящие из логарифмических вероятностей токенов, обусловленных лог-softmax ранее сгенерированных токенов в этом луче. Кортеж `torch.Tensor` с количеством элементов до `max_new_tokens` (один элемент для каждого сгенерированного токена), где каждая тензор имеет форму `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *необязательный*, возвращается при `output_logits=True`) : Необработанные оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax) на каждом шаге генерации. Кортеж из `torch.Tensor` с количеством элементов не более `max_new_tokens` (по одному элементу на каждый сгенерированный токен), где каждый тензор имеет форму `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`, *необязательный*, возвращается при `output_scores=True`) : Индексы лучей для сгенерированного идентификатора токена на каждом шаге генерации. `torch.LongTensor` формы `(batch_size*num_return_sequences, sequence_length)`.

encoder_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя декодера) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`, *необязательный*, возвращается при `output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода эмбеддингов + один для вывода каждого слоя) с формой `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) `torch.Tensor` формы `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, если `output_attentions=True`) : Кортеж (по одному элементу на каждый сгенерированный токен) кортежей (по одному элементу на каждый слой декодера) из `torch.Tensor` формы `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`, *необязательный*, возвращается, когда `output_hidden_states=True`) : Кортеж (по одному элементу для каждого сгенерированного токена) кортежей (по одному элементу для каждого слоя декодера) `torch.Tensor` формы `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`, *необязательный*, возвращается при `use_cache=True`) : Возвращает кэш модели, используемый для ускорения декодирования. У разных моделей разный формат кэша, см. документацию модели. Обычно это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache).

Выходы моделей генерации с архитектурой «кодировщик-декодировщик» при использовании методов лучевого поиска.

## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

Объект [LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) можно использовать для изменения оценок предсказаний, выдаваемых головой языковой модели, в процессе генерации.

#### transformers.AlternatingCodebooksLogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

```python
transformers.AlternatingCodebooksLogitsProcessor(input_start_len: int, semantic_vocab_size: int, codebook_size: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2222)

**Параметры:**

input_start_len (`int`) : Длина исходной входной последовательности.

semantic_vocab_size (`int`) : Размер словаря семантической части, то есть количество токенов, связанных с семантическим словарем.

codebook_size (`int`) : Количество токенов, связанных с кодовой книгой.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), обеспечивающий чередование генерации между двумя кодовыми книгами Bark.

Этот процессор логитов совместим исключительно с тонким подмоделью [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark). Примеры приведены в документации модели.

#### __call__[[transformers.AlternatingCodebooksLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2251)

#### transformers.ClassifierFreeGuidanceLogitsProcessor[[transformers.ClassifierFreeGuidanceLogitsProcessor]]

```python
transformers.ClassifierFreeGuidanceLogitsProcessor(guidance_scale)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2158)

**Параметры:**

guidance_scale (float) : масштаб руководства для classifier free guidance (CFG). CFG включается при установке `guidance_scale > 1`. Более высокий масштаб руководства побуждает модель генерировать образцы, более тесно связанные с входным промптом, обычно за счёт ухудшения качества.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) для classifier free guidance (CFG). Оценки разделяются по размерности batch, где первая половина соответствует условным логитам (предсказанным на основе входного промпта), а вторая половина — безусловным логитам (предсказанным на основе пустого или «null»-промпта). Процессор вычисляет средневзвешенное значение по условным и безусловным логитам, параметризуемое `guidance_scale`.

Подробнее см. в [статье](https://huggingface.co/papers/2306.05284).

Этот процессор логитов совместим исключительно с [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen)

Примеры:

```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)
```

#### __call__[[transformers.ClassifierFreeGuidanceLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2206)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.EncoderNoRepeatNGramLogitsProcessor[[transformers.EncoderNoRepeatNGramLogitsProcessor]]

```python
transformers.EncoderNoRepeatNGramLogitsProcessor(encoder_ngram_size: int, encoder_input_ids: LongTensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1173)

**Параметры:**

encoder_ngram_size (`int`) : Все n-граммы размера `ngram_size` могут встречаться только внутри входных идентификаторов энкодера.

encoder_input_ids (`int`) : encoder_input_ids, которые не должны повторяться в decoder ids.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), работающий аналогично [NoRepeatNGramLogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor), но применяемый исключительно для предотвращения повторения n-грамм, присутствующих в промпте.

Он был разработан для повышения разговорчивости языковой модели путём предотвращения генерации n-грамм, присутствовавших в предыдущих раундах диалога.

Примеры:

```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.
```

#### __call__[[transformers.EncoderNoRepeatNGramLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1222)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.EncoderRepetitionPenaltyLogitsProcessor[[transformers.EncoderRepetitionPenaltyLogitsProcessor]]

```python
transformers.EncoderRepetitionPenaltyLogitsProcessor(penalty: float, encoder_input_ids: LongTensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L440)

**Параметры:**

penalty (`float`) : Параметр для штрафного коэффициента за повторения. Значение 1.0 означает отсутствие штрафа. Значения выше 1.0 поощряют токены промпта. Значения между 0.0 и 1.0 штрафуют токены промпта.

encoder_input_ids (`torch.LongTensor`) : encoder_input_ids, которые должны быть повторены внутри decoder ids.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), работающий аналогично [RepetitionPenaltyLogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor), но с *обратным* штрафом, который применяется к токенам, присутствующим в промпте. Иными словами, штраф выше 1.0 повышает вероятность выбора токенов, которые уже были в промпте.

Он был разработан для предотвращения галлюцинаций в задачах, основанных на входных данных, таких как суммаризация. Хотя изначально он предназначался для моделей с архитектурой «кодировщик-декодировщик», его также можно использовать с моделями, содержащими только декодер, например с LLM.

Примеры:

```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.
```

#### __call__[[transformers.EncoderRepetitionPenaltyLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L486)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.EpsilonLogitsWarper[[transformers.EpsilonLogitsWarper]]

```python
transformers.EpsilonLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L897)

**Параметры:**

epsilon (`float`) : Если установлено значение > 0, для генерации сохраняются только те токены, вероятность которых не ниже `epsilon`.

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все отфильтрованные значения будут установлены на это значение типа float.

min_tokens_to_keep (`int`, *необязательный*, по умолчанию 1) : Минимальное количество токенов, которые не могут быть отфильтрованы.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), выполняющий epsilon-выборку, то есть ограничивающий выбор токенами с `prob >= epsilon`. Если ни один токен не удовлетворяет этому условию, выбираются min_tokens_to_keep токенов с наибольшей вероятностью. Подробнее см. [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191).

Примеры:
```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) ;
<BLANKLINE>
<BLANKLINE>

>>> # 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
```

#### __call__[[transformers.EpsilonLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L952)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.EtaLogitsWarper[[transformers.EtaLogitsWarper]]

```python
transformers.EtaLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1, device: str = 'cpu')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L966)

**Параметры:**

epsilon (`float`) : Значение типа float в диапазоне (0, 1). Гиперпараметр, используемый для вычисления динамического порога отсечения, `eta`. Рекомендуемые значения из статьи варьируются от 3e-4 до 4e-3 в зависимости от размера модели.

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все значения, которые оказываются ниже динамического порога `eta`, устанавливаются в это значение типа float. Этот параметр полезен, когда логиты необходимо изменить для токенов с очень низкой вероятностью, которые должны быть полностью исключены из генерации.

min_tokens_to_keep (`int`, *optional*, по умолчанию 1) : Указывает минимальное количество токенов, которые должны сохраняться для генерации независимо от их вероятностей. Например, если `min_tokens_to_keep` установлено в 1, то для генерации всегда будет сохраняться как минимум один токен, даже если вероятности всех токенов ниже порога `eta`.

device (`str`, *необязательный*, по умолчанию `"cpu"`) : Устройство, на котором будут размещаться тензоры.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), выполняющий eta-выборку — метод фильтрации токенов с вероятностями ниже динамического порога `eta`, который вычисляется на основе комбинации гиперпараметра `epsilon` и энтропии вероятностей токенов, то есть `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. Если ни один токен не удовлетворяет этому условию, выбираются min_tokens_to_keep токенов с наибольшими вероятностями. Метод решает проблему низкого качества длинных текстов, генерируемых нейронными языковыми моделями, что приводит к более связному и плавному тексту. Подробнее см. [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191). Примечание: для работы этого `LogitsProcessor` параметр `do_sample` должен быть установлен в `True`.

Примеры:
```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) ;
<BLANKLINE>
<BLANKLINE>

>>> # 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
```

#### __call__[[transformers.EtaLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1035)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1712)

**Параметры:**

exponential_decay_length_penalty (`tuple(int, float)`) : Этот кортеж должен состоять из: `(start_index, decay_factor)`, где `start_index` указывает, с какого индекса начинается штраф, а `decay_factor` представляет собой коэффициент экспоненциального затухания

eos_token_id (`Union[int, list[int], torch.Tensor]`) : Идентификатор(ы) токена *end-of-sequence*.

input_ids_seq_length (`int`) : Длина входной последовательности.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который экспоненциально увеличивает оценку `eos_token_id` после достижения `start_index`. Это позволяет генерировать более короткие последовательности без жёсткого ограничения по длине, давая возможность предсказать `eos_token` в осмысленной позиции.

Примеры:

```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|>
```

#### __call__[[transformers.ExponentialDecayLengthPenalty.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1798)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.ForcedBOSTokenLogitsProcessor[[transformers.ForcedBOSTokenLogitsProcessor]]

```python
transformers.ForcedBOSTokenLogitsProcessor(bos_token_id: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1590)

**Параметры:**

bos_token_id (`int`) : идентификатор токена, который необходимо принудительно использовать в качестве первого сгенерированного токена.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который принудительно устанавливает указанный токен в качестве первого сгенерированного токена. Используется с моделями encoder-decoder.

Примеры:

```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])
<pad> Ich liebe Kitty.</s>

>>> # 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])
<pad></s>
```

#### __call__[[transformers.ForcedBOSTokenLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1625)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.ForcedEOSTokenLogitsProcessor[[transformers.ForcedEOSTokenLogitsProcessor]]

```python
transformers.ForcedEOSTokenLogitsProcessor(max_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1635)

**Параметры:**

max_length (`int`) : Максимальная длина последовательности, которая будет сгенерирована.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : Идентификатор(ы) токена *end-of-sequence*.

device (`str`, *необязательный*, по умолчанию `"cpu"`) : Устройство, на котором будут размещаться тензоры.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который принудительно устанавливает указанный токен как последний сгенерированный, когда достигается `max_length`.

Примеры:

```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|>
```

#### __call__[[transformers.ForcedEOSTokenLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1681)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.InfNanRemoveLogitsProcessor[[transformers.InfNanRemoveLogitsProcessor]]

```python
transformers.InfNanRemoveLogitsProcessor()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1691)

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который удаляет все значения `nan` и `inf`, чтобы избежать сбоев метода генерации. Обратите внимание, что logits-процессор следует использовать только при необходимости, так как он может замедлять метод генерации.

Для этого обработчика логитов нет примера `generate`, так как не существует корректной комбинации флагов, при которой его использование было бы оправдано.

#### __call__[[transformers.InfNanRemoveLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1700)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.LogitNormalization[[transformers.LogitNormalization]]

```python
transformers.LogitNormalization()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1814)

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) для нормализации оценок с помощью log-softmax. Нормализация оценок важна при поиске луча (beam search) после применения процессоров или трансформаторов логитов, поскольку алгоритм поиска, используемый в этой библиотеке, не выполняет её (он делает это только до применения, но после применения может потребоваться повторная нормализация), при этом он всё равно предполагает, что оценки нормализованы при сравнении гипотез.

Примеры:

```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
```

#### __call__[[transformers.LogitNormalization.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1845)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.LogitsProcessor[[transformers.LogitsProcessor]]

```python
transformers.LogitsProcessor()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L49)

Абстрактный базовый класс для всех процессоров логитов, которые могут применяться во время генерации.

#### __call__[[transformers.LogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L56)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.LogitsProcessorList[[transformers.LogitsProcessorList]]

```python
transformers.LogitsProcessorList(iterable = ())
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L63)

Этот класс можно использовать для создания списка [LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) для последующей обработки входного тензора `scores`. Класс наследуется от list и добавляет специфический метод *__call__* для применения каждого [LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) к входным данным.

#### __call__[[transformers.LogitsProcessorList.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L70)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы, специфичные для процессора логитов.

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.MinLengthLogitsProcessor[[transformers.MinLengthLogitsProcessor]]

```python
transformers.MinLengthLogitsProcessor(min_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L101)

**Параметры:**

min_length (`int`) : минимальная длина, ниже которой значение `eos_token_id` устанавливается в `-float("Inf")`.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : Идентификатор(ы) токена *end-of-sequence*.

device (`str`, *необязательный*, по умолчанию `"cpu"`) : Устройство, на котором будут размещаться тензоры.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), принудительно устанавливающий минимальную длину, обнуляя вероятность токена EOS. Обратите внимание, что для моделей только с декодером, таких как большинство LLM, в длину включается и промпт.

Примеры:

```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
```

#### __call__[[transformers.MinLengthLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L154)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### 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')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L164)

**Параметры:**

prompt_length_to_skip (`int`) : Длина входных токенов. Не является допустимым аргументом при использовании с `generate`, так как длина входа назначается автоматически.

min_new_tokens (`int`) : минимальная длина *новых* токенов, ниже которой значение `eos_token_id` устанавливается в `-float("Inf")`.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : Идентификатор(ы) токена *end-of-sequence*.

device (`str`, *необязательный*, по умолчанию `"cpu"`) : Устройство, на котором будут размещаться тензоры.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) enforcing a min-length of new tokens by setting EOS (End-Of-Sequence) token probability to 0. Contrarily to [MinLengthLogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.MinLengthLogitsProcessor), this processor ignores the prompt.

Примеры:

```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
```

#### __call__[[transformers.MinNewTokensLengthLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L226)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.MinPLogitsWarper[[transformers.MinPLogitsWarper]]

```python
transformers.MinPLogitsWarper(min_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L733)

**Параметры:**

min_p (`float`) : Минимальная вероятность токена, которая масштабируется вероятностью наиболее вероятного токена. Значение должно находиться в диапазоне от 0 до 1. Типичные значения лежат в диапазоне 0.01–0.2, что сопоставимо по селективности с установкой `top_p` в диапазоне 0.99–0.8 (используются значения, обратные обычным значениям `top_p`).

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все отфильтрованные значения будут установлены на это значение типа float.

min_tokens_to_keep (`int`, *необязательный*, по умолчанию 1) : Минимальное количество токенов, которые не могут быть отфильтрованы.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), выполняющий min-p, то есть сохраняющий все токены, вероятность которых превышает минимальную вероятность, масштабированную вероятностью наиболее вероятного токена. В результате фильтр становится более агрессивным при наличии токенов с высокой вероятностью, что является признаком уверенного вывода, от которого не следует отклоняться.

Часто используется вместе с [TemperatureLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TemperatureLogitsWarper). Применяется как альтернатива [TopPLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TopPLogitsWarper) и [TopKLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TopKLogitsWarper).

Создано @menhguin и @kalomaze (никнеймы в GitHub). Код адаптирован из [этого внешнего PR](https://github.com/oobabooga/text-generation-webui/pull/4449/files)

Примеры:

```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) ;
<BLANKLINE>
<BLANKLINE>

>>> # 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
```

#### __call__[[transformers.MinPLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1426)

**Параметры:**

bad_words_ids (`list[list[int]]`) : Список списков идентификаторов токенов, которые не должны генерироваться.

eos_token_id (`Union[int, list[int], torch.Tensor]`, *необязательный*) : Идентификатор(ы) токена *end-of-sequence*.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который гарантирует, что указанные последовательности никогда не будут выбраны.

Чтобы получить идентификаторы токенов слов, которые не должны появляться в сгенерированном тексте, при инициализации токенизатора установите `add_prefix_space=True` и используйте `tokenizer(bad_words, add_special_tokens=False).input_ids`. Аргумент `add_prefix_space` поддерживается только некоторыми медленными токенизаторами, поскольку поведение префиксов в быстрых токенизаторах определяется `pre tokenizers`. Подробнее — [здесь](https://huggingface.co/docs/tokenizers/api/pre-tokenizers).

Примеры:

```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.
```

#### __call__[[transformers.NoBadWordsLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.NoRepeatNGramLogitsProcessor[[transformers.NoRepeatNGramLogitsProcessor]]

```python
transformers.NoRepeatNGramLogitsProcessor(ngram_size: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1102)

**Параметры:**

ngram_size (`int`) : Все n-граммы размера `ngram_size` могут встречаться только один раз.

N-граммы — это группы из «n» последовательных слов, символов или токенов, взятых из текстовой последовательности. Для предложения «She runs fast» биграммы (n=2) будут («she», «runs») и («runs», «fast»). При генерации текста избегание повторений последовательностей слов обеспечивает более разнообразный вывод. Этот [LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) запрещает повторение n-грамм, устанавливая оценки запрещённых токенов в минус бесконечность, что исключает эти токены из рассмотрения при дальнейшей обработке оценок. Обратите внимание, что для моделей только с декодером, таких как большинство LLM, промпт также учитывается при получении n-грамм. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345).

Используйте n-граммные штрафы с осторожностью. Например, штрафование 2-грамм (биграмм) в статье о городе Нью-Йорк может привести к нежелательным результатам, при которых название города встречается в тексте лишь один раз. [Ссылка](https://huggingface.co/blog/how-to-generate)

Примеры:

```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
```

#### __call__[[transformers.NoRepeatNGramLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1149)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.PrefixConstrainedLogitsProcessor[[transformers.PrefixConstrainedLogitsProcessor]]

```python
transformers.PrefixConstrainedLogitsProcessor(prefix_allowed_tokens_fn: Callable, num_beams: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1515)

**Параметры:**

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : Эта функция ограничивает поиск по лучам только разрешёнными токенами на каждом шаге. Функция принимает два аргумента: `inputs_ids` и идентификатор батча `batch_id`. Она должна возвращать список разрешённых токенов для следующего шага генерации, зависящий от ранее сгенерированных токенов `inputs_ids` и идентификатора батча `batch_id`.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), обеспечивающий генерацию с ограничениями и полезный для условной генерации с ограничениями по префиксу. Подробнее см. в разделе [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

Примеры:

```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
```

#### __call__[[transformers.PrefixConstrainedLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1566)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.RepetitionPenaltyLogitsProcessor[[transformers.RepetitionPenaltyLogitsProcessor]]

```python
transformers.RepetitionPenaltyLogitsProcessor(penalty: float, prompt_ignore_length: typing.Union[int, torch.Tensor, NoneType] = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L306)

**Параметры:**

penalty (`float`) : Параметр, задающий штраф за повторение. Значение 1.0 означает отсутствие штрафа. Значения выше 1.0 наказывают ранее сгенерированные токены. Значения между 0.0 и 1.0 поощряют ранее сгенерированные токены.

prompt_ignore_length (`int` или `torch.LongTensor`, *необязательный*) : Количество начальных токенов, которые следует игнорировать, при необходимости с указанием для каждого элемента батча.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который предотвращает повторение предыдущих токенов с помощью штрафного коэффициента. Этот штраф применяется не более одного раза на токен. Обратите внимание, что для моделей только с декодером, таких как большинство LLM, по умолчанию в рассматриваемые токены входит и промпт.

В исходной [статье](https://huggingface.co/papers/1909.05858) авторы рекомендуют использовать штраф порядка 1.2, чтобы достичь хорошего баланса между достоверностью генерации и отсутствием повторов. Чтобы наказать и уменьшить повторы, используйте значения `penalty` выше 1.0, где более высокое значение означает более сильный штраф. Чтобы поощрять и стимулировать повторы, используйте значения `penalty` между 0.0 и 1.0, где более низкое значение означает более сильное поощрение.

Примеры:

```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
```

#### __call__[[transformers.RepetitionPenaltyLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L373)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.SequenceBiasLogitsProcessor[[transformers.SequenceBiasLogitsProcessor]]

```python
transformers.SequenceBiasLogitsProcessor(sequence_bias: list)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1242)

**Параметры:**

sequence_bias (`list[list[Union[list[int], float]]]`) : Список списков, сопоставляющий последовательность токенов её смещающему члену (bias term) (например, `[[[10, 45], -2.0], [[64], -7.5]]`). Положительные смещения повышают вероятность выбора последовательности, а отрицательные — снижают её. Если длина последовательности равна 1, её смещение всегда применяется. В противном случае смещение применяется только в том случае, если рассматриваемая последовательность вот-вот будет завершена (на этапе выбора токена после применения данного процессора).

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), применяющий аддитивное смещение к последовательностям. Смещение накладывается на последний токен последовательности, если следующий сгенерированный токен может её завершить. Следовательно, чтобы максимально эффективно использовать смещение для последовательностей длиной более одного токена, рекомендуется использовать методы beam search (чтобы корректно обрабатывать частично завершённые последовательности с отрицательным смещением) и применять смещение к их префиксам (чтобы обеспечить более раннее применение смещения).

На уровне токенов смещение слова отличается от смещения слова с пробелом перед ним. Если вы хотите сместить «foo» в середине предложения, скорее всего, вам нужно добавить пробел в начале и сместить « foo». Чтобы узнать, почему это так, ознакомьтесь с разделом о токенизаторах в нашем курсе по NLP: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt

Примеры:

```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
```

#### __call__[[transformers.SequenceBiasLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.SuppressTokensAtBeginLogitsProcessor[[transformers.SuppressTokensAtBeginLogitsProcessor]]

```python
transformers.SuppressTokensAtBeginLogitsProcessor(begin_suppress_tokens, begin_index, device: str = 'cpu')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1851)

[SuppressTokensAtBeginLogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor) подавляет список токенов сразу после того, как функция `generate` начинает генерацию, используя токены `begin_index`. Это гарантирует, что токены, определённые параметром `begin_suppress_tokens`, не будут сгенерированы в начале. Класс изначально создан для [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

Примеры:

```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)
```

#### __call__[[transformers.SuppressTokensAtBeginLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1893)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.SuppressTokensLogitsProcessor[[transformers.SuppressTokensLogitsProcessor]]

```python
transformers.SuppressTokensLogitsProcessor(suppress_tokens, device: str = 'cpu')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1904)

Этот процессор можно использовать для подавления списка токенов. Процессор устанавливает их лог-вероятности в `-inf`, чтобы они не генерировались. Первоначально создан для [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

Примеры:

```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)
```

#### __call__[[transformers.SuppressTokensLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1936)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2605)

**Параметры:**

ngram_len (`int`) : Длина n-граммы.

keys (`list[int]`) : Последовательность ключей водяных знаков, по одному для каждой глубины.

sampling_table_size (`int`) : Размер таблицы выборки.

sampling_table_seed (`int`) : Случайное зерно для генерации таблицы выборки.

context_history_size (`int`) : Размер тензора для отслеживания увиденных контекстов.

device (`torch.device`) : Устройство для использования.

skip_first_ngram_calls (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать первые вызовы ngram.

debug_mode (`bool`, *необязательный*, по умолчанию `False`) : Логиты модифицируются до равномерного распределения, которое получалось до применения изменения водяного знака. Это используется для проверки реализации.

Процессор логитов, реализующий методы водяных знаков для моделей генерации текста. Этот класс обеспечивает применение водяного знака SynthID для текста — метода внедрения незаметных сигналов в генерируемый текст для облегчения обнаружения синтетического контента. Он работает за счёт тонкой манипуляции вероятностями выбора токенов в процессе генерации текста таким образом, чтобы эти изменения можно было надёжно восстановить впоследствии для верификации.

Ключевые возможности:
* **Управление состоянием:** поддерживает внутреннее состояние для отслеживания последовательностей токенов и генерации ключей водяных знаков
динамически.

* **Генерация ключей:** вычисляет хеши на основе последовательностей токенов и параметров водяных знаков для создания уникальных ключей
для каждой позиции.

* **Выборка G-значений:** использует заранее вычисленную таблицу выборки для отбора значений водяных знаков (g-значений) на основе
сгенерированные ключи.

* **Корректировка оценки:** применяет рассчитанные g-значения для изменения вероятностей токенов в процессе генерации, встраивая
watermark

* **Обработка повторяющегося контекста:** включает логику, предотвращающую маркировку токенов в повторяющихся контекстах,
сохранение естественности.

* **Маскирование токена EOS:** поддерживает маскирование токенов конца предложения, чтобы предотвратить их включение в водяной знак
вычисления.

* **Вспомогательные функции:** Предоставляет функции для прямого вычисления g-значений, проверки на повторение контекста, создания
Маски токенов EOS и оценка ожидаемых средних значений g.

Подробнее об этом см. в статье по ссылке: https://www.nature.com/articles/s41586-024-08025-4

Примеры:
```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)
```

#### __call__[[transformers.SynthIDTextWatermarkLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2743)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.TemperatureLogitsWarper[[transformers.TemperatureLogitsWarper]]

```python
transformers.TemperatureLogitsWarper(temperature: float)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L238)

**Параметры:**

temperature (`float`) : Строго положительное значение типа float, используемое для модуляции распределения логитов. Значение меньше `1` снижает случайность (и наоборот), при этом `0` эквивалентно переносу всей вероятностной массы на наиболее вероятный токен.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor) для температуры (экспоненциальное масштабирование распределения вероятностей вывода), что фактически означает возможность управления случайностью предсказываемых токенов. Часто используется вместе с [TopPLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TopPLogitsWarper) и [TopKLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TopKLogitsWarper).

Убедитесь, что в аргументах `generate` указано `do_sample=True`, иначе значение температуры не будет иметь никакого эффекта.

Примеры:

```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']
```

#### __call__[[transformers.TemperatureLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L300)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.TopHLogitsWarper[[transformers.TopHLogitsWarper]]

```python
transformers.TopHLogitsWarper(top_h: float, filter_value: float = -inf)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L627)

**Параметры:**

top_h (`float`) : Коэффициент масштабирования для порога на основе энтропии (`tau`). Должен находиться в диапазоне `(0, 1]`.

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все отфильтрованные значения будут установлены на это значение типа float.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), реализующий выборку Top-H — метод декодирования, который адаптивно выбирает подмножество токенов с высокой вероятностью на основе ограничений по энтропии и накопленной вероятности.

Этот метод динамически определяет, сколько токенов следует сохранить, анализируя разницу энтропии выбранного распределения, тем самым балансируя между исследованием и использованием. Это обеспечивает сохранение как разнообразия, так и связности генерируемого текста.

Reference: For details, see *Top-H Decoding: Adapting the Creativity and Coherence with Bounded Entropy in Text Generation* (NeurIPS 2025): https://arxiv.org/abs/2509.02510

Пример:

```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
```

#### __call__[[transformers.TopHLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L678)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : ID входных токенов.

scores (`torch.Tensor` формы `(batch_size, vocab_size)`) : Сырые логиты от модели.

**Возвращает:** `torch.Tensor` формы `(batch_size, vocab_size)`

Обработанные логиты, в которых недействительные токены замаскированы значением `-inf`.

Фильтрует логиты с помощью выборки Top-H.

#### transformers.TopKLogitsWarper[[transformers.TopKLogitsWarper]]

```python
transformers.TopKLogitsWarper(top_k: int, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L571)

**Параметры:**

top_k (`int`) : Количество токенов словаря с наивысшей вероятностью, которые следует сохранить для фильтрации top-k.

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все отфильтрованные значения будут установлены на это значение типа float.

min_tokens_to_keep (`int`, *необязательный*, по умолчанию 1) : Минимальное количество токенов, которые не могут быть отфильтрованы.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), выполняющий top-k, то есть ограничивающий выбор k элементами с наибольшей вероятностью. Часто используется вместе с [TemperatureLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TemperatureLogitsWarper) и [TopPLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TopPLogitsWarper).

Примеры:

```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
```

#### __call__[[transformers.TopKLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L618)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.TopPLogitsWarper[[transformers.TopPLogitsWarper]]

```python
transformers.TopPLogitsWarper(top_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L502)

**Параметры:**

top_p (`float`) : Если значение установлено меньше 1, для генерации сохраняются только наименьшие наборы наиболее вероятных токенов, сумма вероятностей которых составляет `top_p` или выше.

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все отфильтрованные значения будут установлены на это значение типа float.

min_tokens_to_keep (`int`, *необязательный*, по умолчанию 1) : Минимальное количество токенов, которые не могут быть отфильтрованы.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), выполняющий top-p, то есть ограничивающий выбор топ-токенами, суммарная вероятность которых не превышает prob_cut_off. Часто используется вместе с [TemperatureLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TemperatureLogitsWarper) и [TopKLogitsWarper](/docs/transformers/main/ru/internal/generation_utils#transformers.TopKLogitsWarper).

Примеры:

```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) ;
<BLANKLINE>
<BLANKLINE>

>>> # 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
```

#### __call__[[transformers.TopPLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L555)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### transformers.TypicalLogitsWarper[[transformers.TypicalLogitsWarper]]

```python
transformers.TypicalLogitsWarper(mass: float = 0.9, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L809)

**Параметры:**

mass (`float`, *необязательный*, по умолчанию 0.9) : Значение typical_p в диапазоне от 0 до 1 включительно, по умолчанию 0.9.

filter_value (`float`, *необязательный*, по умолчанию -inf) : Все отфильтрованные значения будут установлены на это значение типа float.

min_tokens_to_keep (`int`, *необязательный*, по умолчанию 1) : Минимальное количество токенов, которые не могут быть отфильтрованы.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), выполняющий типичное декодирование. Вдохновлён тем, как люди используют язык, он отдаёт приоритет токенам, чья логарифмическая вероятность близка к энтропии распределения вероятностей токенов. Это означает, что наиболее вероятные токены могут быть отброшены в процессе.

Подробнее см. в разделе [Типовая декомпозиция для генерации естественного языка](https://huggingface.co/papers/2202.00666).

Примеры:

```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)
```

#### __call__[[transformers.TypicalLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L873)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2267)

**Параметры:**

guidance_scale (`float`) : Коэффициент масштабирования для направленного генерирования без классификатора (CFG). CFG активируется при установке `guidance_scale != 1`. Более высокий коэффициент побуждает модель генерировать образцы, более тесно связанные с входным промптом, обычно ценой ухудшения качества. Значение меньше 1 оказывает противоположный эффект, заставляя отрицательный промпт, переданный через negative_prompt_ids (если он есть), действовать как положительный промпт.

model (`PreTrainedModel`): модель, вычисляющая безусловные оценки. Как правило, совпадает с моделью, вычисляющей условные оценки. Обе модели должны использовать один и тот же токенизатор.

unconditional_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре для безусловной ветви. Если не задано, по умолчанию используется последний токен промпта.

unconditional_attention_mask (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска внимания для unconditional_ids.

use_cache (`bool`, *необязательный*, по умолчанию `True`) : Кэшировать ли ключи/значения во время прямого прохода для негативного промпта.

Процессор логитов для Classifier-Free Guidance (CFG). Процессор вычисляет средневзвешенное значение по оценкам из логитов, условных на промпт, и логитов, неусловных (или отрицательных) по промпту, параметризуемое через `guidance_scale`. Неусловные оценки вычисляются внутренне путём промптинга `model` веткой `unconditional_ids`.

Подробнее см. в [статье](https://huggingface.co/papers/2306.17806).

Примеры:

```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"
```

#### __call__[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor.__call__]]

```python
__call__(input_ids, scores)
```

[Источник](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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1944)

**Параметры:**

generate_config (`GenerateConfig`) : Конфигурация генерации, используемая для создания вывода. Требуемые параметры: eos_token_id (`int`, *необязательный*, по умолчанию 50257): Идентификатор токена *конца последовательности*. no_timestamps_token_id (`int`, *необязательный*, по умолчанию 50363): Идентификатор токена `"<|notimestamps|>"`. max_initial_timestamp_index (`int`, *необязательный*, по умолчанию 1): Используется для установки максимального значения начального временного метки. Это предотвращает предсказание моделью временных меток, расположенных слишком далеко в будущем.

begin_index (`int`) : Индекс токена первого сгенерированного моделью токена.

_detect_timestamp_from_logprob (`bool`, *необязательный*) : Можно ли предсказывать временные метки по logprobs для всех временных меток.

[LogitsProcessor](/docs/transformers/main/ru/internal/generation_utils#transformers.LogitsProcessor), который изменяет логиты для генерации меток времени в транскрипте. Когда входные токены достигают определённого порога, процессор устанавливает их оценки в минус бесконечность. Процессор обеспечивает появление токенов меток времени парами, маскируя логиты, которые нарушили бы этот паттерн. Это делается для сохранения согласованности и структуры генерируемых меток времени. Также процессор гарантирует, что если предсказанная вероятность выборки любого из токенов метки времени превышает вероятность любого отдельного немаркерного токена, логиты этих немаркерных токенов устанавливаются в минус бесконечность. Это обеспечивает приоритет генерации меток времени над другими потенциальными токенами.

Подробнее см. в [статье](https://huggingface.co/papers/2212.04356).

Примеры:
``` 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
```

#### __call__[[transformers.WhisperTimeStampLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2034)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2432)

**Параметры:**

vocab_size (`int`) : vocab_size токенизатора модели. Используется для расчёта доли «зелёных» токенов.

device (`str`) : Устройство, на котором размещена модель.

greenlist_ratio (`float`, optional, *optional*, по умолчанию 0.25) : Доля «зелёных» токенов относительно размера словаря. По умолчанию 0.25.

bias (`float`, optional, *optional*, по умолчанию 2.0) : Смещение, добавляемое к логитам выбранных «зелёных» токенов. Если качество генерации текста ухудшается, рекомендуется уменьшить `bias`. Рекомендуемые значения находятся в диапазоне [0.5, 2.0]. По умолчанию 2.0.

hashing_key (`int`, optional, *optional*, по умолчанию 15485863) : Ключ, используемый для хеширования. Если вы разворачиваете эту водяную метку, мы рекомендуем использовать другой закрытый ключ. По умолчанию 15485863 (миллионное простое число).

seeding_scheme (`str`, optional, *optional*, по умолчанию `"lefthash"`) : Схема инициализации, используемая для выбора «зелёных» токенов. Допустимые значения: - "lefthash" (по умолчанию): выбор «зелёных» токенов зависит от последнего токена (алгоритм 2 из статьи) - "selfhash": выбор «зелёных» токенов зависит от самого текущего токена (алгоритм 3 из статьи) Недостаток этой схемы состоит в том, что она учитывает все возможные следующие токены и может работать медленнее, чем "lefthash". Длина контекста предыдущих токенов, используемого для инициализации. Увеличение длины контекста повышает устойчивость водяного знака.

context_width (`int`, *optional*, по умолчанию 1) : Количество предыдущих токенов, используемых при установке seed.

Процессор логитов для водяных знаков в генерируемом тексте. Процессор изменяет оценки выходных данных модели, добавляя небольшой сдвиг к случайному набору «зелёных» токенов перед генерацией следующего токена. Процесс выбора «зелёных» токенов зависит от используемой схемы `seeding_scheme`. Код основан на [оригинальном репозитории](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

Текст, сгенерированный этим `LogitsProcessor`, можно обнаружить с помощью `WatermarkDetector`. Подробности см. в [__call__()](/docs/transformers/main/ru/internal/generation_utils#transformers.WatermarkDetector.__call__),

Подробнее см. в [статье](https://huggingface.co/papers/2306.04634).

Примеры:

```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])
```

#### __call__[[transformers.WatermarkLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2554)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`torch.Tensor` формы `(batch_size, config.vocab_size)`) : Оценки предсказаний языковой модели. Это могут быть логиты для каждого элемента словаря при использовании, отличном от beam search, или log softmax для каждого токена словаря при использовании beam search

**Возвращает:** `torch.Tensor` формы `(batch_size, config.vocab_size)`

Обработанные оценки предсказаний.

## StoppingCriteria[[transformers.StoppingCriteria]]

Объект [StoppingCriteria](/docs/transformers/main/ru/internal/generation_utils#transformers.StoppingCriteria) можно использовать для изменения условий остановки генерации (помимо токена EOS). Обратите внимание, что эта функция доступна только в наших реализациях на PyTorch.

#### transformers.StoppingCriteria[[transformers.StoppingCriteria]]

```python
transformers.StoppingCriteria()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L48)

Абстрактный базовый класс для всех критериев остановки, которые могут применяться во время генерации.

Если ваш критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`.

#### __call__[[transformers.StoppingCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L55)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Оценки предсказаний языковой модели, представленные в виде кортежа с одним тензором на каждый шаг генерации, каждый из которых имеет форму `(batch_size, config.vocab_size)`. Это могут быть оценки для каждого токена словаря до применения SoftMax или после применения SoftMax. Если этот критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`, иначе будет передано значение `None`.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы kwargs для критериев остановки.

**Возвращает:** `torch.BoolTensor`. (`torch.BoolTensor` формы `(batch_size, 1)`)

`True` означает, что генерация для конкретной строки останавливается. `False` означает, что генерация должна продолжаться.

#### transformers.StoppingCriteriaList[[transformers.StoppingCriteriaList]]

```python
transformers.StoppingCriteriaList(iterable = ())
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L610)

#### __call__[[transformers.StoppingCriteriaList.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L611)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Оценки предсказаний языковой модели, представленные в виде кортежа с одним тензором на каждый шаг генерации, каждый из которых имеет форму `(batch_size, config.vocab_size)`. Это могут быть оценки для каждого токена словаря до применения SoftMax или после применения SoftMax. Если этот критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`, иначе будет передано значение `None`.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы kwargs для критериев остановки.

**Возвращает:** `torch.BoolTensor`. (`torch.BoolTensor` формы `(batch_size, 1)`)

`True` означает, что генерация для конкретной строки останавливается. `False` означает, что генерация должна продолжаться.

#### transformers.MaxLengthCriteria[[transformers.MaxLengthCriteria]]

```python
transformers.MaxLengthCriteria(max_length: int, max_position_embeddings: int | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L60)

**Параметры:**

max_length (`int`) : Максимальная длина выходной последовательности в токенах.

max_position_embeddings (`int`, *optional*) : Максимальная длина модели, определяемая атрибутом `config.max_position_embeddings` модели.

Этот класс можно использовать для остановки генерации, когда общее количество сгенерированных токенов превышает `max_length`. Обратите внимание, что для трансформеров только с декодером в это количество входят и начальные токены промпта.

#### __call__[[transformers.MaxLengthCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L76)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Оценки предсказаний языковой модели, представленные в виде кортежа с одним тензором на каждый шаг генерации, каждый из которых имеет форму `(batch_size, config.vocab_size)`. Это могут быть оценки для каждого токена словаря до применения SoftMax или после применения SoftMax. Если этот критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`, иначе будет передано значение `None`.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы kwargs для критериев остановки.

**Возвращает:** `torch.BoolTensor`. (`torch.BoolTensor` формы `(batch_size, 1)`)

`True` означает, что генерация для конкретной строки останавливается. `False` означает, что генерация должна продолжаться.

#### transformers.MaxTimeCriteria[[transformers.MaxTimeCriteria]]

```python
transformers.MaxTimeCriteria(max_time: float, initial_timestamp: float | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L89)

**Параметры:**

max_time (`float`) : Максимально допустимое время генерации в секундах.

initial_timestamp (`float`, *необязательный*, по умолчанию `time.time()`) : Начало разрешённого времени генерации.

Этот класс можно использовать для остановки генерации, если общее время генерации превышает заданное значение. По умолчанию отсчёт времени начинается при инициализации этой функции. Вы можете переопределить это поведение, передав параметр `initial_timestamp`.

#### __call__[[transformers.MaxTimeCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L106)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Оценки предсказаний языковой модели, представленные в виде кортежа с одним тензором на каждый шаг генерации, каждый из которых имеет форму `(batch_size, config.vocab_size)`. Это могут быть оценки для каждого токена словаря до применения SoftMax или после применения SoftMax. Если этот критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`, иначе будет передано значение `None`.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы kwargs для критериев остановки.

**Возвращает:** `torch.BoolTensor`. (`torch.BoolTensor` формы `(batch_size, 1)`)

`True` означает, что генерация для конкретной строки останавливается. `False` означает, что генерация должна продолжаться.

#### transformers.StopStringCriteria[[transformers.StopStringCriteria]]

```python
transformers.StopStringCriteria(tokenizer: PreTrainedTokenizerBase, stop_strings: str | list[str])
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L112)

**Параметры:**

tokenizer (`PreTrainedTokenizer`) : токенизатор, связанный с моделью (необходим для извлечения словаря и токенизации последовательностей завершения)

stop_strings (`Union[str, list[str]]`) : список строк, которые должны завершать генерацию. Если передана одна строка, она будет обработана как список с одним элементом.

Этот класс можно использовать для остановки генерации, когда появляются определённые последовательности символов. Он предварительно обрабатывает строки вместе с словарём токенизатора, чтобы найти позиции, в которых токены могут корректно завершить стоп-строки.

Генерация останавливается сразу после того, как сгенерированный токен завершает любую из строк остановки. Нам нужно отлавливать любой случай, при котором строка остановки присутствует в декодированном выводе, что означает необходимость также учитывать случаи с «выступами» с одного или обоих концов. Чтобы проиллюстрировать это более наглядно, для строки остановки "stop" совпадение будет срабатывать при любой из следующих последовательностей токенов:

- ["st", "op"]
- ["stop"]
- ["st", "opera"]
- ["сто", "ппер"]
- ["las", "topper"]
- ["s", "to", "pped"]

Обратите внимание, что совпадение будет обнаружено только в том случае, если стоп-строка находится в конце сгенерированной последовательности. Иными словами, эти последовательности не приведут к обнаружению совпадения:

- ["stop", "at"]
- ["st", "op", "at"]
- ["st", "opera", "tion"]

Причина, по которой совпадение не происходит, заключается в том, что стоп-строка не пересекается с последним токеном. Если можно удалить один или несколько токенов с конца последовательности, не разрушая стоп-строку, то этот критерий не будет соответствовать данной стоп-строке. Это сделано намеренно: поскольку данная проверка выполняется после генерации каждого токена, мы не можем пропустить валидную стоп-строку, если она была сгенерирована, но мы не хотим останавливать генерацию только потому, что стоп-строка где-то присутствует в предыдущих input_ids.

Но как именно выполняется сопоставление? Мы делаем это довольно запутанным образом, потому что хотим, чтобы весь процесс сопоставления был компилируемым с помощью Torch или XLA, а это означает, что мы не можем использовать стандартные строковые методы. Тем не менее, при некоторой доработке, сопоставление строк можно выполнить с помощью чисто тензорных операций. Мы начнём с описания алгоритма, который мы используем со стандартными строковыми операциями, а в конце объясним, как он преобразуется в чисто тензорные операции.

Ключ к алгоритму заключается в следующем наблюдении: поскольку строка-остановщик должна пересекаться с концом последовательности токенов, мы можем начать с конца последовательности и двигаться в обратном направлении. Конкретно, мы проверяем наличие пересечения между началом последнего токена и концом stop_string, или, иначе говоря, stop_string[-i:] == token[:i] для некоторого i > 0. Если посмотреть на приведённые выше положительные примеры, то видно, что последний токен во всех них удовлетворяет этому свойству:

- ["st", "op"] (пересечение — "op", длина пересечения == 2)
- ["stop"]  (пересечение — "stop", длина пересечения == 4)
- ["st", "opera"] (пересечение — "op", длина пересечения == 2)
- ["sto", "pper"] (пересечение — «p», длина пересечения == 1)
- ["las", "topper"] (пересечение — "top", длина пересечения == 3)
- ["s", "to", "pped"] (пересечение — «p», длина пересечения == 1)

Невозможно построить совпадающую последовательность, не обладающую этим свойством (при желании вы можете проверить это самостоятельно). Однако, хотя такое перекрытие начала последнего токена и конца стоп-строки необходимо для совпадения, оно не является достаточным. Нам также нужно проверить, что остальная часть последовательности токенов согласуется со стоп-строкой.

How do we do that? Let's use ["s", "to", "pped"] as an example. We know that the final token, "pped", has an overlap of 1 with the stop string, "stop". We then go back to the previous token, "to". Since we have already matched 1 character from the stop string, the remainder to check is "sto". We check that the next token "to" matches the end of the remainder, which it does. We have now matched 3 characters from the stop string, and the remainder to match is "s". We go back to the previous token again, which is also "s". This is a match, and so we have matched the entire stop string.

А как это работает, когда токены выходят за начало стоп-строки? Рассмотрим пример ["las", "topper"]. Последний токен, "topper", имеет пересечение длиной 3 со стоп-строкой "stop". Следовательно, оставшаяся часть стоп-строки для совпадения — это "s". Мы возвращаемся к предыдущему токену, "las". Поскольку оставшаяся для совпадения часть — это просто "s" длиной 1, мы рассматриваем только последний символ токена, то есть "s". Это совпадает со стоп-строкой, и, таким образом, вся строка совпадает.

Но как вычислить эти совпадения с помощью тензорных операций? Просто: мы эффективно предварительно вычисляем необходимую информацию для всех токенов! Для каждого токена мы вычисляем:
- Его пересечение с концом строки остановки, если оно есть
- Позиции внутри строки остановки, где токен совпадает, включая совпадения, выходящие за начало строки.
- Общая длина токена

Например, для токена "pped" мы вычислим перекрытие в конце, равное 1, отсутствие внутренних совпадающих позиций и длину 4. Для токена "to" мы вычислим отсутствие перекрытия в конце, одну внутреннюю совпадающую позицию 1 (считая от конца) и длину 2. Для токена "s" мы вычислим отсутствие перекрытия в конце, одну внутреннюю совпадающую позицию 3 (снова считая от конца) и длину 1.

Пока у нас есть эта информация, мы можем выполнить описанный выше алгоритм без каких-либо операций сравнения строк. Достаточно выполнить следующие шаги:
- Проверьте, есть ли у последнего токена перекрытие в конце со строкой начала
- Продолжайте движение назад, отслеживая, какая часть строки остановки уже совпала.
- На каждом шаге проверяйте, является ли текущая позиция одной из допустимых позиций для следующего токена
- Продолжайте, пока не произойдет сбой совпадения или пока не будет полностью совпасть вся строка остановки

Again, consider ["s", "to", "pped"] as an example. "pped" has an end overlap of 1, so we can begin a match. We have matched 1 character so far, so we check that the next token "to", has 1 as a valid position (again, counting from the end). It does, so we add the length of "to" to our position tracker. We have now matched 3 characters, so we check that the next token "s" has 3 as a valid position. It does, so we add its length to the position tracker. The position tracker is now 4, which is the length of the stop string. We have matched the entire stop string.

Во втором случае, ["las", "topper"], у "topper" есть перекрытие конца длиной 3, поэтому мы можем начать сопоставление. На данный момент мы сопоставили 3 символа, поэтому проверяем, является ли 3 допустимой позицией для следующего токена "las". Да, это так, поскольку мы допускаем, чтобы токены совпадали с позициями, выходящими за начало стоп-строки. Мы добавляем его длину к счётчику позиций. Теперь счётчик позиций равен 6, что больше длины стоп-строки! Не паникуйте — это тоже считается совпадением со стоп-строкой. Мы сопоставили всю стоп-строку.

Примеры:

```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
```

#### __call__[[transformers.StopStringCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L475)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Оценки предсказаний языковой модели, представленные в виде кортежа с одним тензором на каждый шаг генерации, каждый из которых имеет форму `(batch_size, config.vocab_size)`. Это могут быть оценки для каждого токена словаря до применения SoftMax или после применения SoftMax. Если этот критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`, иначе будет передано значение `None`.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы kwargs для критериев остановки.

**Возвращает:** `torch.BoolTensor`. (`torch.BoolTensor` формы `(batch_size, 1)`)

`True` означает, что генерация для конкретной строки останавливается. `False` означает, что генерация должна продолжаться.

#### transformers.EosTokenCriteria[[transformers.EosTokenCriteria]]

```python
transformers.EosTokenCriteria(eos_token_id: typing.Union[int, list[int], torch.Tensor])
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L537)

**Параметры:**

eos_token_id (`Union[int, list[int], torch.Tensor]`) : Идентификатор(ы) токена *end-of-sequence*.

Этот класс можно использовать для остановки генерации в момент, когда сгенерирован токен «конец последовательности». По умолчанию используется `model.generation_config.eos_token_id`.

#### __call__[[transformers.EosTokenCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, new_token_length: int = 1, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L554)

**Параметры:**

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : Оценки предсказаний языковой модели, представленные в виде кортежа с одним тензором на каждый шаг генерации, каждый из которых имеет форму `(batch_size, config.vocab_size)`. Это могут быть оценки для каждого токена словаря до применения SoftMax или после применения SoftMax. Если этот критерий остановки зависит от входного параметра `scores`, убедитесь, что вы передаёте `return_dict_in_generate=True, output_scores=True` в `generate`, иначе будет передано значение `None`.

new_token_length (`int`, *необязательный*, по умолчанию `1`) : Количество токенов, которые будут проверяться на соответствие критериям. Будут проверены последние `new_token_length` токена в каждом элементе батча.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные аргументы kwargs для критериев остановки.

**Возвращает:** `torch.BoolTensor`. (`torch.BoolTensor` формы `(batch_size, 1)`)

`True` означает, что генерация для конкретной строки останавливается. `False` означает, что генерация должна продолжаться.

## Стимеры[[transformers.TextStreamer]]

#### transformers.TextStreamer[[transformers.TextStreamer]]

```python
transformers.TextStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, **decode_kwargs: Any)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L41)

**Параметры:**

tokenizer (`AutoTokenizer`) : токенизатор, используемый для декодирования токенов.

skip_prompt (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать промпт для `.generate()`. Полезно, например, для чат-ботов.

decode_kwargs (`dict`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод `decode` токенизатора.

Простой стример текста, который выводит токены в stdout сразу после формирования целых слов.

Примеры:

```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,
```

#### конец[[transformers.TextStreamer.end]]

```python
end()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L113)

Очищает оставшийся кэш и выводит символ новой строки в стандартный поток вывода.

#### on_finalized_text[[transformers.TextStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L127)

Выводит новый текст в stdout. Если поток завершается, также выводит перевод строки.

#### put[[transformers.TextStreamer.put]]

```python
put(value)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L79)

Получает токены, декодирует их и выводит в stdout по мере формирования целых слов.

#### transformers.TextIteratorStreamer[[transformers.TextIteratorStreamer]]

```python
transformers.TextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L156)

**Параметры:**

tokenizer (`AutoTokenizer`) : токенизатор, используемый для декодирования токенов.

skip_prompt (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать промпт для `.generate()`. Полезно, например, для чат-ботов.

timeout (`float`, *необязательный*) : Тайм-аут для очереди текста. Если `None`, очередь будет блокироваться бесконечно. Полезно для обработки исключений в `.generate()`, когда он вызывается в отдельном потоке.

decode_kwargs (`dict`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод `decode` токенизатора.

Поток, который хранит готовый к выводу текст в очереди для использования приложением ниже по цепочке в качестве итератора. Это полезно для приложений, которым требуется неблокирующий доступ к сгенерированному тексту (например, в интерактивной демонстрации на Gradio).

Примеры:

```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L208)

Добавьте новый текст в очередь. Если поток завершается, также добавьте в очередь сигнал остановки.

#### transformers.AsyncTextIteratorStreamer[[transformers.AsyncTextIteratorStreamer]]

```python
transformers.AsyncTextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L225)

**Параметры:**

tokenizer (`AutoTokenizer`) : токенизатор, используемый для декодирования токенов.

skip_prompt (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать промпт для `.generate()`. Полезно, например, для чат-ботов.

timeout (`float`, *необязательный*) : Тайм-аут для очереди текста. Если `None`, очередь будет блокироваться бесконечно. Полезно для обработки исключений в `.generate()`, когда он вызывается в отдельном потоке.

decode_kwargs (`dict`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод `decode` токенизатора.

**Исключения:** ``TimeoutError``

- ``TimeoutError`` -- если время генерации токенов превышает значение тайм-аута.

Стример, который хранит текст, готовый к выводу, в очереди для использования приложением ниже по потоку в качестве асинхронного итератора. Это полезно для приложений, которым требуется асинхронный доступ к сгенерированному тексту (например, в интерактивной демонстрации Gradio).

Примеры:

```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L285)

Добавьте новый текст в очередь. Если поток завершается, также добавьте в очередь сигнал остановки.

#### transformers.TextDiffusionStreamer[[transformers.TextDiffusionStreamer]]

```python
transformers.TextDiffusionStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, sleep_time: float | None = None, **decode_kwargs: Any)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L303)

**Параметры:**

tokenizer (`AutoTokenizer`) : токенизатор, используемый для декодирования токенов.

skip_prompt (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать промпт для `.generate()`. Полезно, например, для чат-ботов.

sleep_time (`float`, *необязательный*) : Время сна между черновиками диффузии, что может быть полезно для визуализации промежуточных результатов.

decode_kwargs (`dict`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод `decode` токенизатора.

Стример, выводящий результаты текстовой диффузии. Промежуточные шаги диффузии (черновики) являются временными и перезаписываются последующими черновиками, а удаляются после вывода подтверждённого текста.

Если вы работаете в среде, такой как tmux, черновой текст может не перезаписываться.

Примеры:

```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)
```

#### конец[[transformers.TextDiffusionStreamer.end]]

```python
end()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L392)

Очищает оставшийся кэш и выводит новую строку.

#### put[[transformers.TextDiffusionStreamer.put]]

```python
put(value)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L387)

Получает подтверждённые токены, очищает черновик и навсегда выводит их.

#### put_draft[[transformers.TextDiffusionStreamer.put_draft]]

```python
put_draft(value, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L365)

Получает полную последовательность черновых токенов, декодирует их и выводит жёлтым цветом. Перезаписывает предыдущий черновик.

## Кэши[[transformers.CacheLayerMixin]]

#### transformers.CacheLayerMixin[[transformers.CacheLayerMixin]]

```python
transformers.CacheLayerMixin(**kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L23)

Базовый абстрактный класс для кэша одного слоя.

#### обновление[[transformers.CacheLayerMixin.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](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()
```

[Источник](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)
```

[Источник](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()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L63)

Возвращает максимальную длину последовательности, которую может хранить слой. Значение `-1` означает отсутствие ограничения по длине или неопределённое ограничение, например, для слоя динамического внимания, который неограниченно растёт, или слоя линейного внимания, у которого нет измерения длины последовательности.

#### сброс[[transformers.CacheLayerMixin.reset]]

```python
reset()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L84)

Сбрасывает значения кэша, сохраняя объекты

#### reorder_cache[[transformers.CacheLayerMixin.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L97)

Перестраивает кэш этого слоя для beam search.

#### lazy_initialization[[transformers.CacheLayerMixin.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L49)

#### transformers.DynamicLayer[[transformers.DynamicLayer]]

```python
transformers.DynamicLayer(**kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L104)

Слой кэша, который динамически расширяется по мере генерации новых токенов. Это значение по умолчанию для генеративных моделей. Он хранит состояния ключей и значений в виде тензоров формы `[batch_size, num_heads, seq_len, head_dim]`.

#### обновление[[transformers.DynamicLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L119)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

**Возвращает:** tuple[`torch.Tensor`, `torch.Tensor`]

Состояния ключей и значений.

Обновите кэши ключей и значений на месте и верните необходимые состояния ключей и значений.

#### lazy_initialization[[transformers.DynamicLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113)

#### crop[[transformers.DynamicLayer.crop]]

```python
crop(tokens_to_remove: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L164)

Удалите токены `tokens_to_remove` из текущего слоя кэша.

#### batch_repeat_interleave[[transformers.DynamicLayer.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L183)

Повторите кэш `repeats` раз по размерности батча.

#### batch_select_indices[[transformers.DynamicLayer.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L189)

Оставляйте в кэше только `indices` в размерности батча.

#### transformers.StaticLayer[[transformers.StaticLayer]]

```python
transformers.StaticLayer(max_cache_len: int, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L403)

**Параметры:**

max_cache_len (`int`) : Максимальное количество токенов, которое может быть сохранено; используется для предварительного выделения памяти для тензоров.

Статический слой кэша, который хранит состояния ключей и значений в виде статических тензоров формы `[batch_size, num_heads, max_cache_len, head_dim]`. Он лениво выделяет свои базовые тензоры полного размера, а затем изменяет их на месте. Создан для поддержки `torch.compile`.

#### обновление[[transformers.StaticLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L461)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

**Возвращает:** tuple[`torch.Tensor`, `torch.Tensor`]

Состояния ключей и значений.

Обновите кэши ключей и значений на месте и верните необходимые состояния ключей и значений.

#### lazy_initialization[[transformers.StaticLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423)

Ленивая инициализация тензоров ключей и значений. Это позволяет получать все свойства (dtype, device, num_heads в случае TP и т. д.) непосредственно во время выполнения, что крайне удобно, поскольку исключает необходимость последующего перемещения устройств, изменения dtypes и т. д. при каждом `update` (что также могло бы нарушить статические адреса dynamo).

Если это нежелательно, можно вызвать `early_initialization(...)` непосредственно на объекте Cache, что вызовет данную функцию заранее (например, это требуется для `torch.export`). Это также необходимо, если сам prefill попадает в скомпилированную область (например, при использовании chunked prefill).

#### transformers.StaticSlidingWindowLayer[[transformers.StaticSlidingWindowLayer]]

```python
transformers.StaticSlidingWindowLayer(max_cache_len: int, sliding_window: int, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L510)

**Параметры:**

max_cache_len (`int`) : Максимальное количество токенов, которое может быть сохранено; используется для предварительного выделения памяти для тензоров.

sliding_window (`int`) : размер скользящего окна.

Статический слой кэша, который хранит состояния ключей и значений в виде статических тензоров формы `[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]`. Он лениво выделяет свои полные базовые тензоры, а затем изменяет их на месте. Создан для поддержки `torch.compile`.

#### обновление[[transformers.StaticSlidingWindowLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L531)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

**Возвращает:** tuple[`torch.Tensor`, `torch.Tensor`]

Состояния ключей и значений.

Обновите кэши ключей и значений на месте и верните необходимые состояния ключей и значений.

#### lazy_initialization[[transformers.StaticSlidingWindowLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423)

Ленивая инициализация тензоров ключей и значений. Это позволяет получать все свойства (dtype, device, num_heads в случае TP и т. д.) непосредственно во время выполнения, что крайне удобно, поскольку исключает необходимость последующего перемещения устройств, изменения dtypes и т. д. при каждом `update` (что также могло бы нарушить статические адреса dynamo).

Если это нежелательно, можно вызвать `early_initialization(...)` непосредственно на объекте Cache, что вызовет данную функцию заранее (например, это требуется для `torch.export`). Это также необходимо, если сам prefill попадает в скомпилированную область (например, при использовании chunked prefill).

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L854)

#### обновление[[transformers.QuantoQuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

**Возвращает:** tuple[`torch.Tensor`, `torch.Tensor`]

Состояния ключей и значений.

Обновите кэши ключей и значений на месте и верните необходимые состояния ключей и значений.

#### lazy_initialization[[transformers.QuantoQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L909)

#### обновление[[transformers.HQQQuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

**Возвращает:** tuple[`torch.Tensor`, `torch.Tensor`]

Состояния ключей и значений.

Обновите кэши ключей и значений на месте и верните необходимые состояния ключей и значений.

#### lazy_initialization[[transformers.HQQQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113)

#### transformers.Fp8QuantizedLayer[[transformers.Fp8QuantizedLayer]]

```python
transformers.Fp8QuantizedLayer()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L966)

Квантованный слой, хранящий ключевые и значения в формате 8-битного плавающего числа. Масштаб на тензор фиксируется после первого `update`, поэтому новые состояния добавляются как есть: без остаточного кэша и без повторной квантизации.

Более тонкий вариант лучше разместить здесь, а не под `QuantizedLayer`, поскольку группировка по размерности head сохраняет возможность добавления состояний и лишь превращает хранимый масштаб в тензор.

#### обновление[[transformers.Fp8QuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L994)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

**Возвращает:** tuple[`torch.Tensor`, `torch.Tensor`]

Состояния ключей и значений.

Обновите кэши ключей и значений на месте и верните необходимые состояния ключей и значений.

#### lazy_initialization[[transformers.Fp8QuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[Источник](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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1453)

**Параметры:**

layers (`Optional`, *необязательный*) : список заранее созданных `CacheLayerMixin` или `LinearAttentionCacheLayerMixin`. Если опущен (`None`), будет использован `layer_class_to_replicate`.

layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`, *необязательный*) : Используется только в том случае, если `layers` не указан (`None`); в этом случае он служит базовым классом для каждого слоя, а слои добавляются лениво, как только `update` вызывается с `layer_idx`, превышающим текущий список слоёв.

offloading (`bool`, *необязательный*, по умолчанию `False`) : Выполнять ли выгрузку слоёв на `cpu` для экономии памяти GPU.

offload_only_non_sliding (`bool`, *необязательный*, по умолчанию `True`) : Если `offloading` установлен в `True`, этот параметр дополнительно определяет, будут ли выгружаться только не-скользящие слои (поскольку скользящие слои обычно имеют небольшой размер, выгружать их не нужно, а их пропуск ускоряет процесс).

Объект `Cache` представляет собой, по сути, список объектов `CacheLayerMixin`, по одному на каждый слой модели. Он служит контейнером для кэша каждого слоя.

#### обновление[[transformers.Cache.update]]

```python
update(key_states: Tensor, value_states: Tensor, layer_idx: int, *args, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1540)

**Параметры:**

key_states (`torch.Tensor`) : Новые ключевые состояния для кэширования.

value_states (`torch.Tensor`) : новое значение, которое нужно сохранить в кэше.

layer_idx (`int`) : Индекс слоя, для которого кэшируются состояния.

**Возвращаемое значение:**

Кортеж, содержащий обновлённые состояния ключей и значений.

Обновляет кэш новыми `key_states` и `value_states` для слоя `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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1669)

Инициализируйте все слои заранее (в противном случае они инициализируются лениво при первом вызове `update`). Это полезно для наших рецептов `export`, так как `export` требует, чтобы всё было готово заранее.

#### get_seq_length[[transformers.Cache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1706)

Возвращает длину последовательности кэша для указанного слоя.

#### get_mask_sizes[[transformers.Cache.get_mask_sizes]]

```python
get_mask_sizes(query_length: int, layer_idx: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1776)

Возвращает кортеж (kv_length, kv_offset), соответствующий длине и смещению, которые будут возвращены для данного слоя с индексом `layer_idx`. Затем маски формируются в соответствии с заданными для каждого слоя значениями длины и смещения (kv_length, kv_offset) и шаблонами.

#### get_max_length[[transformers.Cache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1730)

Возвращает максимальную длину кэша. Если `layer_idx` не указан (значение по умолчанию), возвращается максимальное значение по всем слоям. В противном случае возвращается максимальное поддерживаемое значение для указанного слоя. Значение `-1` означает отсутствие максимума или неопределённый максимум, например, для слоёв динамического внимания, которые могут расти неограниченно, или для слоёв линейного внимания, у которых нет измерения длины последовательности.

#### сброс[[transformers.Cache.reset]]

```python
reset()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1813)

Рекурсивно сбросить тензоры всех слоёв

#### reorder_cache[[transformers.Cache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1818)

Перестановка кэша для beam search

#### crop[[transformers.Cache.crop]]

```python
crop(tokens_to_remove: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1823)

Удаляет токены `tokens_to_remove` из текущего объекта Cache. Для слоёв, которым не требуется хранить все прошлые состояния в памяти, например для слоёв со скользящим окном или слоёв линейного внимания, это также приведёт к уменьшению размера кэшированных состояний до их минимального рабочего размера. Это означает, что `crop(0)` не всегда будет являться операцией без эффекта (no-op), поскольку он всё равно может удалять бесполезные состояния (то есть состояния, которые не нужны для следующего вызова `forward`) из объекта Cache.

#### batch_repeat_interleave[[transformers.Cache.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1833)

Повторение и чередование кэша

#### batch_select_indices[[transformers.Cache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1838)

Выбор индексов из кэша

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1960)

**Параметры:**

ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`, *необязательный*) : изначально добавлен для совместимости с `torch.distributed` (DDP). По сути, это `map(gather_map, zip(*caches))`, то есть каждый элемент итерируемого объекта содержит состояния ключей и значений для слоя, собранные с помощью torch.distributed по всем репликам (shape=[global batch size, num_heads, seq_len, head_dim]). Примечание: для корректной работы этот аргумент также должен быть первым

config (`PreTrainedConfig`, *необязательный*) : Конфигурация модели, для которой будет использоваться этот Cache. Если передана, используется для проверки скользящей или гибридной структуры слоёв, что значительно снижает требования к памяти для кэшированных тензоров до `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

offloading (`bool`, *необязательный*, по умолчанию `False`) : Выполнять ли выгрузку слоёв на `cpu` для экономии памяти GPU.

offload_only_non_sliding (`bool`, *необязательный*, по умолчанию `False`) : Если `offloading` равно `True`, этот параметр дополнительно определяет, будут ли выгружаться только не-скользящие слои (поскольку скользящие слои обычно имеют небольшой размер, выгружать их не нужно, а их пропуск ускоряет процесс).

Кэш, который динамически расширяется по мере генерации новых токенов. Это значение по умолчанию для генеративных моделей. Он хранит состояния ключей и значений в виде списка `CacheLayer`, по одному на каждый слой. Ожидаемая форма каждого тензора в `CacheLayer` — `[batch_size, num_heads, seq_len, head_dim]`. Если передана конфигурация, дополнительно проверяется наличие скользящей или гибридной структуры кэша, что значительно снижает требования к памяти для кэшированных тензоров до `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

См. `Cache` для подробностей о методах, общих для всех классов кэша.

Пример:

```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2056)

**Параметры:**

config (`PreTrainedConfig`) : конфигурация модели, для которой будет использоваться данный Cache. Она используется для проверки структуры со скользящим или гибридным слоем и инициализации каждого слоя соответственно.

max_cache_len (`int`) : Максимальное количество токенов, которые должен хранить этот Cache.

offloading (`bool`, *необязательный*, по умолчанию `False`) : Выполнять ли выгрузку слоёв на `cpu` для экономии памяти GPU.

offload_only_non_sliding (`bool`, *необязательный*, по умолчанию `True`) : Если `offloading` установлен в `True`, этот параметр дополнительно определяет, будут ли выгружаться только не-скользящие слои (поскольку скользящие слои обычно имеют небольшой размер, выгружать их не нужно, а их пропуск ускоряет процесс).

Класс Static Cache для использования с `torch.compile(model)` и `torch.export()`. Он проверяет `config` на наличие потенциальной гибридной структуры кэша и инициализирует каждый слой соответственно.

См. `Cache` для подробностей о методах, общих для всех классов кэша.

Пример:

```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2113)

**Параметры:**

backend (`str`) : Квантование backend, которое следует использовать. Одно из `("quanto", "hqq", "fp8")`.

config (`PreTrainedConfig`) : конфигурация модели, для которой будет использоваться этот Cache.

nbits (`int`, *optional*, по умолчанию 4) : Количество бит для квантования.

axis_key (`int`, *optional*, по умолчанию 0) : Ось, по которой выполняется квантование ключей.

axis_value (`int`, *optional*, по умолчанию 0) : Ось, по которой выполняется квантование значений.

q_group_size (`int`, *optional*, по умолчанию 64) : Квантование выполняется по каналам согласно заданному `q_group_size` как для ключей, так и для значений.

residual_length (`int`, *optional*, по умолчанию 128) : Максимальная ёмкость кэша исходной точности.

Кэш квантизатора, аналогичный описанному в статье [KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache](https://huggingface.co/papers/2402.02750). Он позволяет модели генерировать последовательности большей длины, не выделяя чрезмерного объема памяти для ключей и значений, за счет применения квантизации. Кэш имеет два типа хранилища: одно для исходной точности и одно для квантованного кэша. Значение `residual length` задается как максимальная емкость кэша исходной точности. Когда длина превышает максимальную емкость, кэш исходной точности отбрасывается и переносится в квантованный кэш. Квантизация выполняется по каналам с заданным `q_group_size` как для ключей, так и для значений, в отличие от описанного в статье.

См. `Cache` для подробностей о методах, общих для всех классов кэша.

Последние пять аргументов настраивают групповые целочисленные бэкенды. Бэкенд `fp8` выполняет квантование на уровне тензора и отклоняет их.

#### transformers.EncoderDecoderCache[[transformers.EncoderDecoderCache]]

```python
transformers.EncoderDecoderCache(*caches)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2199)

**Параметры:**

caches (`Iterable`) : Как правило, итерируемый объект длины 2, содержащий два объекта `Cache`: первый — для self-attention, второй — для cross-attention. Опционально может быть итерируемым объектом длины 1, содержащим `tuple[tuple[torch.Tensor]]` (обычно используется для совместимости с torch dp и ddp).

Базовый абстрактный класс для всех кэшей энкодер-декодера. Может использоваться для хранения комбинаций кэшей само-внимания и кросс-внимания.

См. `Cache` для подробностей о методах, общих для всех классов кэша.

Пример:

```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2316)

Повторяйте кэш `repeats` раз по размерности батча. Используется в контрастивном поиске (на Hub).

#### batch_select_indices[[transformers.EncoderDecoderCache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2322)

Сохраняйте только `indices` в размерности батча кэша. Используется в контрастивном поиске (на Hub).

#### crop[[transformers.EncoderDecoderCache.crop]]

```python
crop(tokens_to_remove: int)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2309)

Удалите токены `tokens_to_remove` из текущего слоя кэша.

#### get_max_length[[transformers.EncoderDecoderCache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2284)

Возвращает максимальную длину последовательности (т. е. максимальную ёмкость) объекта кэша

#### get_seq_length[[transformers.EncoderDecoderCache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2280)

Возвращает длину последовательности кэшированных состояний. Индекс слоя можно передать необязательно.

#### reorder_cache[[transformers.EncoderDecoderCache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2294)

Переставляет кэш для beam search, учитывая выбранные индексы лучей.

## Утилиты водяных знаков[[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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1458)

Класс, содержащий аргументы для генерации водяного знака, который следует передавать в `GenerationConfig` при вызове `generate`. Подробнее об аргументах см. в [этой статье](https://huggingface.co/papers/2306.04634).

Принимает следующие ключи:
- greenlist_ratio (`float`): Используется для водяных знаков. Доля «зелёных» токенов от размера словаря. По умолчанию 0.25.
- bias (`float`): Используется при водяных знаках. Смещение, добавляемое к логитам выбранных «зелёных» токенов. По умолчанию равно 2.0.
- hashing_key (`int`): Ключ хеширования, используемый для водяных знаков. По умолчанию — 15485863 (миллионное простое число).
- seeding_scheme (`str`): Алгоритм, используемый для водяных знаков. Допустимые значения:
  - lefthash (по умолчанию): выбор «зелёных» токенов зависит от последнего токена (алгоритм 2 из статьи)
  - Выбор токенов "selfhash": "green" зависит от самого текущего токена (алгоритм 3 из статьи). Недостаток этой схемы состоит в том, что она учитывает все возможные следующие токены и может работать медленнее, чем "lefthash".
- context_width(`int`): длина контекста предыдущих токенов, используемая при инициализации. Увеличение длины контекста делает водяной знак более устойчивым.

#### __call__[[transformers.WatermarkingConfig.__call__]]

```python
__call__(*args, **kwargs)
```

Вызовите self как функцию.

#### 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L71)

**Параметры:**

model_config (`PreTrainedConfig`) : конфигурация модели, которая будет использоваться для получения аргументов, специфичных для модели, применяемых при генерации.

device (`str`) : Устройство, которое использовалось при генерации текста с водяным знаком.

watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : Точно те же параметры и аргументы водяного знака, которые использовались при генерации текста.

ignore_repeated_ngrams (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли учитывать каждый уникальный n-грамм только один раз.

max_cache_size (`int`, *optional*, по умолчанию 128) : Максимальный размер, используемый для LRU-кэширования алгоритмов посева/выборки, вызываемых для каждого токена.

Детектор для обнаружения текста, сгенерированного с водяным знаком. Для работы детектору необходимо передать точно те же настройки, что и при генерации текста, чтобы воспроизвести формирование «зелёного списка» водяного знака и тем самым обнаружить его. Сюда входят правильное устройство, использованное при генерации текста, правильные аргументы водяного знака и правильный размер словаря токенизатора. Код основан на [оригинальном репозитории](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

Подробнее см. в [статье](https://huggingface.co/papers/2306.04634).

Примеры:

```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])
```

#### __call__[[transformers.WatermarkDetector.__call__]]

```python
__call__(input_ids: LongTensor, z_threshold: float = 3.0, return_dict: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L193)

**Параметры:**

input_ids (`torch.LongTensor`) : Водяной знак сгенерированного текста. Рекомендуется удалить промпт, так как он может повлиять на обнаружение.

z_threshold (`Dict`, *необязательный*, по умолчанию `3.0`) : Изменение этого порога влияет на чувствительность детектора. Более высокий порог z снижает чувствительность, а более низкий — повышает её.

return_dict (`bool`,  *необязательный*, по умолчанию `False`) : Указывает, следует ли возвращать `~generation.WatermarkDetectorOutput`. В противном случае возвращаются булевы предсказания,

**Возвращает:** `WatermarkDetectorOutput` или `np.ndarray`

Объект `WatermarkDetectorOutput`, если `return_dict=True`, иначе `np.ndarray`.

ma

#### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]]

```python
transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L252)

**Параметры:**

watermarking_depth (`int`, *необязательный*) : Количество слоев турнира.

base_rate (`float`, *необязательный*, по умолчанию 0.5) : Априорная вероятность P(w) того, что текст содержит водяной знак.

Это класс конфигурации для хранения настроек модели [BayesianDetectorModel](/docs/transformers/main/ru/internal/generation_utils#transformers.BayesianDetectorModel). Он используется для создания модели Bayesian Detector в соответствии с указанными аргументами.

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

#### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]]

```python
transformers.BayesianDetectorModel(config)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L359)

**Параметры:**

config ([BayesianDetectorConfig](/docs/transformers/main/ru/internal/generation_utils#transformers.BayesianDetectorConfig)) : класс конфигурации модели, содержащий все параметры модели. Инициализация с помощью файла конфигурации не загружает веса модели, а только её конфигурацию. Для загрузки весов модели используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained).

Байесовский классификатор для обнаружения водяных знаков.

Этот детектор использует правило Байеса для вычисления оценки водяного знака, которая представляет собой сигмоиду логарифма отношения апостериорных вероятностей P(watermarked|g_values) и P(unwatermarked|g_values). Дополнительные сведения см. в разделе BayesianScore в статье. URL статьи: https://www.nature.com/articles/s41586-024-08025-4

Обратите внимание, что этот детектор работает только с неискажающими водяными знаками на основе турниров, использующими распределение значений g по Бернулли(0.5).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.BayesianDetectorModel.forward]]

```python
forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L448)

**Параметры:**

g_values (`torch.Tensor` формы `(batch_size, seq_len, watermarking_depth, ...)`) : g-значения (со значениями 0 или 1)

mask : Двоичный массив формы [batch_size, seq_len], указывающий, какие значения g следует использовать. Значения g, для которых маска равна 0, отбрасываются.

**Возвращаемое значение:**

p(watermarked | g_values), формы [batch_size].

Вычисляет водяной знак posterior 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1538)

**Параметры:**

ngram_len (`int`) : Длина n-граммы.

keys (`list[int]`) : Последовательность ключей водяных знаков, по одному для каждой глубины.

context_history_size (`int`, *optional*, по умолчанию 1024) : Размер тензора для отслеживания просмотренных контекстов.

sampling_table_seed (`int`, *optional*, по умолчанию 0) : Случайное зерно для генерации таблицы выборки.

sampling_table_size (`int`, *необязательный*, по умолчанию 65536) : Размер таблицы выборки.

skip_first_ngram_calls (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли пропускать первые вызовы ngram.

debug_mode (`bool`, *необязательный*, по умолчанию `False`) : Логиты модифицируются до равномерного распределения, которое получалось до применения изменения водяного знака. Это используется для проверки реализации.

Класс, содержащий аргументы для генерации водяного знака, который следует передавать в `GenerationConfig` при вызове `generate`. Подробнее об аргументах см. в [этой статье](https://www.nature.com/articles/s41586-024-08025-4).

Примеры:
```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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L492)

**Параметры:**

detector_module ([BayesianDetectorModel](/docs/transformers/main/ru/internal/generation_utils#transformers.BayesianDetectorModel)) : объект модуля байесовского детектора, инициализированный параметрами. См. https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text для примеров использования.

logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : процессор логитов, используемый для водяных знаков.

tokenizer (`Any`) : токенизатор, используемый для модели.

Класс детектора текстовых водяных знаков SynthID.

Этот класс должен быть инициализирован с использованием обученного модуля bayesian detector, см. скрипт проверки в examples/synthid_text/detector_training.py, например, для обучения, сохранения и загрузки этого модуля. В этой папке также представлен пример использования данного детектора.

Примеры:
```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)
```

#### __call__[[transformers.SynthIDTextWatermarkDetector.__call__]]

```python
__call__(tokenized_outputs: Tensor)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L539)

## Утилиты компиляции[[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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1630)

**Параметры:**

fullgraph (`bool`, *необязательный*, по умолчанию `False`) : Если False (по умолчанию), выполняется попытка обнаружить компилируемые области, которые будут оптимизированы. Если True, требуется, чтобы вся функция могла быть захвачена в единый граф. Если это невозможно (то есть, если присутствуют разрывы графа), будет выброшена ошибка.

dynamic (`bool` или `None`, *необязательный*) : Нужно ли пытаться использовать графы с динамическими формами.

backend (`str` или `Callable`, *необязательный*, по умолчанию `"inductor"`) : Используемый backend.

mode (`str`, *необязательный*, по умолчанию `"reduce-overhead"`) : управляет балансом между производительностью и накладными расходами.

options (`dict`, *необязательный*) : Словарь с параметрами для передачи в backend.

Класс, содержащий аргументы, относящиеся к поведению `torch.compile` при использовании автоматической компиляции в `generate`. Дополнительные сведения об аргументах см. в [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html).

Примеры:
```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]
```

#### __call__[[transformers.CompileConfig.__call__]]

```python
__call__(*args, **kwargs)
```

Вызовите self как функцию.