# XLNet

## Обзор

Модель XLNet была предложена в статье [XLNet: Generalized Autoregressive Pretraining for Language Understanding](https://huggingface.co/papers/1906.08237) Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le. XLnet представляет собой расширение модели Transformer-XL, обученной с использованием авторегрессионного метода для изучения двунаправленных контекстов путём максимизации ожидаемой вероятности по всем перестановкам порядка факторизации входной последовательности.

Аннотация из статьи следующая:

*Благодаря способности моделировать двунаправленный контекст, предобучение на основе автокодирования с шумоподавлением, как в BERT, обеспечивает лучшие результаты по сравнению с подходами предобучения, основанными на авторегрессионном языковом моделировании. Однако, полагаясь на искажение входных данных с помощью масок, BERT игнорирует зависимости между замаскированными позициями и страдает от рассогласования между этапами предобучения и дообучения. Учитывая эти преимущества и недостатки, мы предлагаем XLNet — обобщенный метод авторегрессионного предобучения, который (1) позволяет обучаться на двунаправленных контекстах, максимизируя ожидаемую правдоподобность по всем перестановкам порядка факторизации, и (2) преодолевает ограничения BERT благодаря своей авторегрессионной формулировке. Кроме того, XLNet интегрирует идеи из Transformer-XL, передовой авторегрессионной модели, в процесс предобучения. Эмпирически, при сопоставимых условиях экспериментов, XLNet превосходит BERT на 20 задачах, часто с большим отрывом, включая ответы на вопросы, естественный языковой вывод, анализ тональности и ранжирование документов.*

Эта модель была предоставлена пользователем [thomwolf](https://huggingface.co/thomwolf). Исходный код можно найти [здесь](https://github.com/zihangdai/xlnet/).

## Советы по использованию

- Конкретный шаблон внимания можно контролировать на этапах обучения и тестирования с помощью входного параметра `perm_mask`.
- В связи с трудностями обучения полностью авто-регрессивной модели при различных порядках факторизации, XLNet предобучается с использованием в качестве целевых только подмножества выходных токенов, которые выбираются с помощью входного параметра `target_mapping`.
- Чтобы использовать XLNet для последовательного декодирования (т. е. не в полностью двунаправленном режиме), используйте входы `perm_mask` и `target_mapping` для управления диапазоном внимания и выводами
- XLNet — одна из немногих моделей, не имеющих ограничения на длину последовательности.
- XLNet — это не традиционная авторегрессионная модель, но использует стратегию обучения, основанную на ней. Он переставляет токены в предложении, а затем позволяет модели использовать последние n токенов для предсказания токена n+1. Поскольку всё это делается с помощью маски, предложение фактически подаётся в модель в правильном порядке, но вместо маскирования первых n токенов для n+1, XLNet использует маску, которая скрывает предыдущие токены в некоторой заданной перестановке 1,…,длина последовательности.
- XLNet также использует тот же механизм рекуррентности, что и Transformer-XL, для построения долгосрочных зависимостей.

## Ресурсы

- [Руководство по задаче классификации текста](../tasks/sequence_classification)
- [Руководство по задаче классификации токенов](../tasks/token_classification)
- [Руководство по задаче вопрос-ответ](../tasks/question_answering)
- [Руководство по задаче каузального языкового моделирования](../tasks/language_modeling)
- [Руководство по задаче с множественным выбором](../tasks/multiple_choice)

## XLNetConfig[[transformers.XLNetConfig]]

#### transformers.XLNetConfig[[transformers.XLNetConfig]]

```python
transformers.XLNetConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32000, d_model: int = 1024, n_layer: int = 24, n_head: int = 16, d_inner: int = 4096, d_head: int | None = None, ff_activation: str = 'gelu', attn_type: str = 'bi', initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, dropout: float | int = 0.1, mem_len: int | None = 512, reuse_len: int | None = None, use_mems_eval: bool = True, use_mems_train: bool = False, bi_data: bool = False, clamp_len: int = -1, same_length: bool = False, summary_type: str = 'last', summary_use_proj: bool = True, summary_activation: str = 'tanh', summary_last_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, pad_token_id: int | None = 5, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = True)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/configuration_xlnet.py#L28)

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

vocab_size (`int`, *необязательный*, по умолчанию `32000`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

d_model (`int`, *необязательный*, по умолчанию `1024`) : Размер слоев кодировщика и пулера.

n_layer (`int`, *необязательный*, по умолчанию `24`) : Количество скрытых слоев в декодере Transformer.

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

d_inner (`int`, *необязательный*, по умолчанию `4096`) : Размерность представлений MLP.

d_head (`int`, *optional*) : Размер измерения внимания. Если None, по умолчанию будет использовано hidden_size // num_attention_heads

ff_activation (`str` или `Callable`, *необязательный*, по умолчанию `"gelu"`) : Нелинейная функция активации (функция или строка). Если передана строка, поддерживаются значения `"gelu"`, `"relu"`, `"silu"` и `"gelu_new"`.

attn_type (`str`, *необязательный*, по умолчанию `"bi"`) : Тип внимания, используемый моделью. Установите `"bi"` для XLNet, `"uni"` для Transformer-XL.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-12`) : Значение epsilon, используемое слоями нормализации.

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

mem_len (`int` или `None`, *необязательный*) : Количество токенов для кэширования. Пары ключ/значение, которые уже были предварительно вычислены в предыдущем прямом проходе, не будут вычисляться повторно. Подробнее см. в [быстром старте](https://huggingface.co/transformers/quickstart.html#using-the-past).

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

use_mems_eval (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли модели механизм рекуррентной памяти в режиме оценки.

use_mems_train (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли модели использовать механизм рекуррентной памяти в режиме обучения. Для предварительного обучения рекомендуется установить `use_mems_train` в `True`. Для дообучения рекомендуется установить `use_mems_train` в `False`, как обсуждается [здесь](https://github.com/zihangdai/xlnet/issues/41#issuecomment-505102587). Если `use_mems_train` установлен в `True`, необходимо убедиться, что обучающие батчи корректно предобработаны, *например* `batch_1 = [[This line is], [This is the]]` и `batch_2 = [[ the first line], [ second line]]`, и что все батчи имеют одинаковый размер.

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

clamp_len (`int`, *optional*, по умолчанию -1) : Ограничивает все относительные расстояния, превышающие clamp_len. Установка этого атрибута в -1 означает отсутствие ограничения.

same_length (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли одинаковую длину внимания для каждого токена.

summary_type (`str`, *optional*, по умолчанию "last") : Аргумент, используемый при выполнении сводки последовательности. Применяется в моделях классификации последовательностей и множественного выбора. Должен быть одним из следующих вариантов: - `"last"`: Использовать скрытое состояние последнего токена (как в XLNet). - `"first"`: Использовать скрытое состояние первого токена (как в BERT). - `"mean"`: Использовать среднее значение скрытых состояний всех токенов. - `"cls_index"`: Передать Tensor с позицией токена классификации (как в GPT/GPT-2). - `"attn"`: Пока не реализовано, использовать многоголовное внимание.

summary_use_proj (`bool`, *необязательный*, по умолчанию `True`) : Аргумент, используемый при выполнении сводки последовательности. Применяется в моделях классификации последовательностей и множественного выбора. Определяет, следует ли добавлять проекцию после извлечения вектора.

summary_activation (`str`, *необязательный*) : Аргумент, используемый при выполнении сводки последовательности. Применяется в моделях классификации последовательностей и множественного выбора. Передайте `"tanh"`, чтобы применить активацию tanh к выходу; любое другое значение приведет к отсутствию активации.

summary_last_dropout (`float`, *optional*, по умолчанию 0.1) : Используется в моделях классификации последовательностей и множественного выбора. Коэффициент dropout, применяемый после проекции и функции активации.

start_n_top (`int`, *необязательный*, по умолчанию 5) : Используется в скрипте оценки SQuAD.

end_n_top (`int`, *необязательный*, по умолчанию 5) : Используется в скрипте оценки SQuAD.

pad_token_id (`int`, *необязательный*, по умолчанию `5`) : Идентификатор токена, используемый для выравнивания в словаре.

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

eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемого для обозначения конца потока в словаре.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

Это класс конфигурации для хранения настроек XLNetModel. Он используется для создания модели Xlnet в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [xlnet/xlnet-large-cased](https://huggingface.co/xlnet/xlnet-large-cased)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Примеры:

```python
>>> from transformers import XLNetConfig, XLNetModel

>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## XLNetTokenizer[[transformers.XLNetTokenizer]]

#### transformers.XLNetTokenizer[[transformers.XLNetTokenizer]]

```python
transformers.XLNetTokenizer(vocab: str | list[tuple[str, float]] | None = None, unk_id: int = 0, do_lower_case = False, remove_space = True, keep_accents = False, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', sep_token = '<sep>', pad_token = '<pad>', cls_token = '<cls>', mask_token = '<mask>', _spm_precompiled_charsmap = None, additional_special_tokens = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/tokenization_xlnet.py#L38)

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

vocab (`list of tuples`, *optional*) : Список кортежей (токен, оценка) для модели Unigram. Если не указан, используется пустой список.

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

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

remove_space (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли удалять пробельные символы при токенизации (удаление лишних пробелов перед строкой и после неё).

keep_accents (`bool`, *необязательный*, по умолчанию `False`) : Сохранять ли акценты при токенизации.

bos_token (`str`, *optional*, по умолчанию `"<s>"`) : Токен начала последовательности, использовавшийся во время предварительного обучения. Может использоваться в качестве токена классификатора последовательности. При построении последовательности с использованием специальных токенов этот токен не используется для обозначения начала последовательности. Для этой цели применяется токен `cls_token`.

eos_token (`str`, *необязательный*, по умолчанию `"</s>"`) : Токен конца последовательности. При построении последовательности с использованием специальных токенов этот токен не используется для обозначения конца последовательности. Вместо него применяется токен `sep_token`.

unk_token (`str`, *необязательный*, по умолчанию `"<unk>"`) : Неизвестный токен. Токен, отсутствующий в словаре, не может быть преобразован в ID, вместо этого ему присваивается данный токен.

sep_token (`str`, *необязательный*, по умолчанию `"<sep>"`) : Токен-разделитель, который используется при построении последовательности из нескольких последовательностей, например, двух последовательностей для классификации последовательностей или текста и вопроса для ответа на вопросы. Он также используется в качестве последнего токена последовательности, построенной с помощью специальных токенов.

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

cls_token (`str`, *необязательный*, по умолчанию `"<cls>"`) : Токен классификатора, используемый при классификации последовательности (классификация всей последовательности, а не посимвольная классификация). Это первый токен последовательности, если она построена со специальными токенами.

mask_token (`str`, *необязательный*, по умолчанию `"<mask>"`) : Токен, используемый для маскирования значений. Это тот токен, который применяется при обучении модели с использованием маскированного языкового моделирования. Именно этот токен модель будет пытаться предсказать.

additional_special_tokens (`list[str]`, *необязательный*, по умолчанию `["<eop>", "<eod>"]`) : Дополнительные специальные токены, используемые токенизатором.

Создайте токенизатор XLNet (на базе библиотеки *tokenizers* от HuggingFace). Основан на [Unigram](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=unigram#models).

Этот токенизатор наследуется от [TokenizersBackend](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.TokenizersBackend), который содержит большинство основных методов. За дополнительной информацией об этих методах следует обращаться к этому суперклассу.

#### get_special_tokens_mask[[transformers.XLNetTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1337)

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

token_ids_0 : список идентификаторов для (возможно, уже отформатированной) последовательности.

token_ids_1 : Не используется, если `already_has_special_tokens=True`. В этом случае должно быть None.

already_has_special_tokens : Указывает, уже ли последовательность отформатирована со специальными токенами.

**Возвращаемое значение:** список целых чисел в диапазоне [0, 1]

1 для специального токена, 0 для токена последовательности.

Получить идентификаторы последовательностей из списка токенов, в который не добавлены специальные токены.

Для быстрых токенизаторов коллабораторы данных вызывают этот метод с `already_has_special_tokens=True`, чтобы построить маску для уже отформатированной последовательности. В этом случае маска вычисляется путём проверки принадлежности элементов `all_special_ids`.

#### save_vocabulary[[transformers.XLNetTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L547)

## Специфические выходные данные XLNet[[transformers.models.xlnet.modeling_xlnet.XLNetModelOutput]]

#### transformers.models.xlnet.modeling_xlnet.XLNetModelOutput[[transformers.models.xlnet.modeling_xlnet.XLNetModelOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetModelOutput(last_hidden_state: Tensor, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L659)

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

last_hidden_state (`torch.Tensor` формы `(batch_size, num_predict, hidden_size)`) : Последовательность скрытых состояний на последнем слое модели. `num_predict` соответствует `target_mapping.shape[1]`. Если `target_mapping` равно `None`, то `num_predict` соответствует `sequence_length`.

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип возвращаемого значения [XLNetModel](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetModel).

#### transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput[[transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L684)

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

loss (`torch.Tensor` формы *(1,)*, *необязательный*, возвращается, если задан `labels`) : Потери языковой модели (для предсказания следующего токена).

logits (`torch.Tensor` формы `(batch_size, num_predict, config.vocab_size)`) : Оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax). `num_predict` соответствует `target_mapping.shape[1]`. Если `target_mapping` равно `None`, то `num_predict` соответствует `sequence_length`.

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип возвращаемого значения [XLNetLMHeadModel](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetLMHeadModel).

#### transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L712)

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

loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если указан `label`) : Потери классификации (или регрессии, если config.num_labels==1).

logits (`torch.Tensor` формы `(batch_size, config.num_labels)`) : Оценки классификации (или регрессии, если config.num_labels==1) (до SoftMax).

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип результата [XLNetForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForSequenceClassification).

#### transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L762)

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

loss (`torch.Tensor` формы *(1,)*, *необязательный*, возвращается, если задан `labels`) : Потери классификации.

logits (`torch.Tensor` формы `(batch_size, num_choices)`) : *num_choices* — это второе измерение входных тензоров (см. *input_ids* выше). Оценки классификации (до SoftMax).

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип результата [XLNetForMultipleChoice](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForMultipleChoice).

#### transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L737)

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

loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) : Потери классификации.

logits (`torch.Tensor` формы `(batch_size, sequence_length, config.num_labels)`) : Оценки классификации (до SoftMax).

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип возвращаемого значения `XLNetForTokenClassificationOutput`.

#### transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L789)

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

loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) : Суммарная потеря извлечения пропусков представляет собой сумму кросс-энтропии для начальной и конечной позиций.

start_logits (`torch.Tensor` формы `(batch_size, sequence_length,)`) : Оценки начала спана (до SoftMax).

end_logits (`torch.Tensor` формы `(batch_size, sequence_length,)`) : Оценки конца спана (до SoftMax).

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип возвращаемого значения [XLNetForQuestionAnsweringSimple](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForQuestionAnsweringSimple).

#### transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput[[transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput]]

```python
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, start_top_log_probs: typing.Optional[torch.Tensor] = None, start_top_index: typing.Optional[torch.LongTensor] = None, end_top_log_probs: typing.Optional[torch.Tensor] = None, end_top_index: typing.Optional[torch.LongTensor] = None, cls_logits: typing.Optional[torch.Tensor] = None, mems: list[torch.Tensor] | None = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L817)

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

loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если заданы и `start_positions`, и `end_positions`) : Потери классификации в виде суммы потерь классификации начального токена, конечного токена (и is_impossible, если задан).

start_top_log_probs (`torch.Tensor` формы `(batch_size, config.start_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) : Логарифмические вероятности для config.start_n_top наиболее вероятных стартовых токенов (поиск с ограничением луча).

start_top_index (`torch.LongTensor` формы `(batch_size, config.start_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) : Индексы для top config.start_n_top вариантов начальных токенов (beam-search).

end_top_log_probs (`torch.Tensor` формы `(batch_size, config.start_n_top * config.end_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) : Логарифмические вероятности для `config.start_n_top * config.end_n_top` наиболее вероятных вариантов конечного токена (beam-search).

end_top_index (`torch.LongTensor` формы `(batch_size, config.start_n_top * config.end_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) : Индексы для `config.start_n_top * config.end_n_top` наиболее вероятных вариантов конечного токена (поиск с ветвлением).

cls_logits (`torch.Tensor` формы `(batch_size,)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) : Логарифмические вероятности для метки `is_impossible` ответов.

mems (`list[torch.Tensor]` длиной `config.n_layers`) : Содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.

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

attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Тип возвращаемого значения [XLNetForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForQuestionAnswering).

## XLNetModel[[transformers.XLNetModel]]

#### transformers.XLNetModel[[transformers.XLNetModel]]

```python
transformers.XLNetModel(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L851)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Xlnet, выводящая необработанные скрытые состояния без какого-либо специализированного слоя наверху.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L976)

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

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

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, sequence_length`, *необязательный*) : Маска для исключения токенов отбивки из внимания. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отбивки, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **маскируются**, - 0 для токенов, которые **не маскируются**. Можно использовать только один из `input_mask` и `attention_mask`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность при задачах последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [XLNetModelOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetModelOutput) или `tuple(torch.Tensor)`

Объект [XLNetModelOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward модели [XLNetModel](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetModel) переопределяет специальный метод `__call__`.

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, num_predict, hidden_size)`) -- Последовательность скрытых состояний на последнем слое модели.

  `num_predict` соответствует `target_mapping.shape[1]`. Если `target_mapping` равно `None`, то `num_predict` соответствует `sequence_length`.
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## XLNetLMHeadModel[[transformers.XLNetLMHeadModel]]

#### transformers.XLNetLMHeadModel[[transformers.XLNetLMHeadModel]]

```python
transformers.XLNetLMHeadModel(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1215)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель XLNet с головкой для моделирования языка сверху (линейный слой с весами, связанными с входными эмбеддингами).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetLMHeadModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1290)

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

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

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, sequence_length`, *необязательный*) : Маска для исключения токенов отбивки из внимания. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отбивки, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **маскируются**, - 0 для токенов, которые **не маскируются**. Можно использовать только один из `input_mask` и `attention_mask`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size, num_predict)`, *необязательный*) : Метки для маскированного языкового моделирования. `num_predict` соответствует `target_mapping.shape[1]`. Если `target_mapping` равно `None`, то `num_predict` соответствует `sequence_length`. Метки должны соответствовать замаскированным входным словам, которые необходимо предсказать, и зависят от `target_mapping`. Обратите внимание, что для выполнения стандартного авто-регрессивного языкового моделирования к `input_ids` необходимо добавить токен ** (см. функцию `prepare_inputs_for_generation` и примеры ниже) Индексы выбираются из диапазона `[-100, 0, ..., config.vocab_size]` Все метки, установленные в `-100`, игнорируются; функция потерь вычисляется только для меток в диапазоне `[0, ..., config.vocab_size]`

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность при задачах последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

logits_to_keep (`Union[int, torch.Tensor]`, *необязательный*, по умолчанию `0`) : Если передано значение типа `int`, вычисляются logits для последних `logits_to_keep` токенов. Если передано `0`, logits вычисляются для всех `input_ids` (специальный случай). Для генерации нужны logits только последнего токена, и вычисление их только для этого токена позволяет сэкономить память, что становится весьма значимым для длинных последовательностей или большого размера словаря. Если передано значение типа `torch.Tensor`, оно должно быть одномерным и соответствовать индексам, которые нужно сохранить в измерении длины последовательности. Это полезно при использовании упакованного формата тензоров (одно измерение для batch и длины последовательности).

**Возвращает:** [XLNetLMHeadModelOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput) или `tuple(torch.Tensor)`

Объект [XLNetLMHeadModelOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward модели [XLNetLMHeadModel](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetLMHeadModel) переопределяет специальный метод `__call__`.

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

- **loss** (`torch.Tensor` формы *(1,)*, *необязательный*, возвращается, если задан `labels`) -- Потери языковой модели (для предсказания следующего токена).
- **logits** (`torch.Tensor` формы `(batch_size, num_predict, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax).

  `num_predict` соответствует `target_mapping.shape[1]`. Если `target_mapping` равно `None`, то `num_predict` соответствует `sequence_length`.
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

```python
>>> from transformers import AutoTokenizer, XLNetLMHeadModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")

>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
...     tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
...     0
... )  # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0  # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
...     (1, 1, input_ids.shape[1]), dtype=torch.float
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)

>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
...     0
... ]  # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]

>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
...     tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
...     0
... )  # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
...     :, :, -1
... ] = 1.0  # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
...     (1, 1, input_ids.shape[1]), dtype=torch.float
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)

>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
...     outputs.logits
... )  # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
```

## XLNetForSequenceClassification[[transformers.XLNetForSequenceClassification]]

#### transformers.XLNetForSequenceClassification[[transformers.XLNetForSequenceClassification]]

```python
transformers.XLNetForSequenceClassification(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1462)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель XLNet с головой для классификации/регрессии последовательности (линейный слой поверх пуллинг-выхода), например, для задач GLUE.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1475)

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

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

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, sequence_length`, *необязательный*) : Маска для исключения токенов отбивки из внимания. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отбивки, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **маскируются**, - 0 для токенов, которые **не маскируются**. Можно использовать только один из `input_mask` и `attention_mask`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия).

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность при задачах последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [XLNetForSequenceClassificationOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput) или `tuple(torch.Tensor)`

Объект [XLNetForSequenceClassificationOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward класса [XLNetForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForSequenceClassification) переопределяет специальный метод `__call__`.

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `label`) -- Потери классификации (или регрессии, если config.num_labels==1).
- **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax.
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример классификации с одной меткой:

```python
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Пример многоклассовой классификации:

```python
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-large-cased", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLNetForSequenceClassification.from_pretrained(
...     "xlnet/xlnet-large-cased", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## XLNetForMultipleChoice[[transformers.XLNetForMultipleChoice]]

#### transformers.XLNetForMultipleChoice[[transformers.XLNetForMultipleChoice]]

```python
transformers.XLNetForMultipleChoice(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1694)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель Xlnet с головной частью для классификации с множественным выбором (линейный слой поверх пул-вывода и softmax), например, для задач RocStories/SWAG.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1705)

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

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

token_type_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательно*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, num_choices, sequence_length`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отступов, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **замаскированы**, - 0 для токенов, которые **не замаскированы**. Можно использовать только один из `input_mask` и `attention_mask`.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

inputs_embeds (`torch.Tensor` формы `(batch_size, num_choices, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации с множественным выбором. Индексы должны быть в диапазоне `[0, ...,

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность при задачах последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [XLNetForMultipleChoiceOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput) или `tuple(torch.Tensor)`

Объект [XLNetForMultipleChoiceOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward класса [XLNetForMultipleChoice](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForMultipleChoice) переопределяет специальный метод `__call__`.

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

- **loss** (`torch.Tensor` формы *(1,)*, *необязательный*, возвращается, если задан `labels`) -- Потери классификации.
- **logits** (`torch.Tensor` формы `(batch_size, num_choices)`) -- *num_choices* — это второе измерение входных тензоров (см. *input_ids* выше).

  Оценки классификации (до SoftMax).
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, XLNetForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-large-cased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLNetForTokenClassification[[transformers.XLNetForTokenClassification]]

#### transformers.XLNetForTokenClassification[[transformers.XLNetForTokenClassification]]

```python
transformers.XLNetForTokenClassification(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1586)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Трансформер Xlnet с головой классификации токенов (линейный слой поверх выходных скрытых состояний), например, для задач распознавания именованных сущностей (NER).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1597)

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

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

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, sequence_length`, *необязательный*) : Маска для исключения токенов отбивки из внимания. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отбивки, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **маскируются**, - 0 для токенов, которые **не маскируются**. Можно использовать только один из `input_mask` и `attention_mask`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации с множественным выбором. Индексы должны находиться в диапазоне `[0, ..., num_choices]`, где *num_choices* — размер второго измерения входных тензоров (см. *input_ids* выше).

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность задач последовательного декодирования. Состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность задач последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [XLNetForTokenClassificationOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput) или `tuple(torch.Tensor)`

Объект [XLNetForTokenClassificationOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward класса [XLNetForTokenClassification](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForTokenClassification) переопределяет специальный метод `__call__`.

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации.
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.num_labels)`) — Оценки классификации (до SoftMax).
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, XLNetForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-large-cased")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## XLNetForQuestionAnsweringSimple[[transformers.XLNetForQuestionAnsweringSimple]]

#### transformers.XLNetForQuestionAnsweringSimple[[transformers.XLNetForQuestionAnsweringSimple]]

```python
transformers.XLNetForQuestionAnsweringSimple(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1838)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель XLNet с головой классификации пролётов (span classification head) для задач извлекающего вопросно-ответного типа, таких как SQuAD (линейные слои поверх выходных скрытых состояний для вычисления `span start logits` и `span end logits`).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1849)

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

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

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, sequence_length`, *необязательный*) : Маска для исключения токенов отбивки из внимания. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отбивки, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **маскируются**, - 0 для токенов, которые **не маскируются**. Можно использовать только один из `input_mask` и `attention_mask`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

start_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) начала размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь.

end_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) конца размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь.

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность при задачах последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [XLNetForQuestionAnsweringSimpleOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput) или `tuple(torch.Tensor)`

Объект [XLNetForQuestionAnsweringSimpleOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward класса [XLNetForQuestionAnsweringSimple](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForQuestionAnsweringSimple) переопределяет специальный метод `__call__`.

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Суммарная функция потерь для извлечения пролёгов представляет собой сумму кросс-энтропии для начальных и конечных позиций.
- **start_logits** (`torch.Tensor` формы `(batch_size, sequence_length,)`) — Оценки начала пропусков (до SoftMax).
- **end_logits** (`torch.Tensor` формы `(batch_size, sequence_length,)`) -- Оценки конца пролета (до SoftMax).
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-large-cased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```

## XLNetForQuestionAnswering[[transformers.XLNetForQuestionAnswering]]

#### transformers.XLNetForQuestionAnswering[[transformers.XLNetForQuestionAnswering]]

```python
transformers.XLNetForQuestionAnswering(config: XLNetConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1959)

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

config ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Трансформер Xlnet с головой для классификации пропусков (span classification) сверху для задач извлекающего вопросно-ответного типа, таких как SQuAD (линейный слой поверх выходных скрытых состояний для вычисления `span start logits` и `span end logits`).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.XLNetForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, mems: typing.Optional[torch.Tensor] = None, perm_mask: typing.Optional[torch.Tensor] = None, target_mapping: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, input_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: typing.Optional[torch.Tensor] = None, use_mems: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/xlnet/modeling_xlnet.py#L1973)

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

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

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

mems (`list[torch.Tensor]` длины `config.n_layers`) : содержит предварительно вычисленные скрытые состояния (см. вывод `mems` ниже). Можно использовать для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать в качестве `input_ids`, так как они уже были вычислены. Чтобы использовать `mems`, параметр `use_mems` должен быть установлен в `True`.

perm_mask (`torch.Tensor` формы `(batch_size, sequence_length, sequence_length)`, *необязательный*) : Маска, указывающая шаблон внимания для каждого входного токена со значениями из `[0, 1]`:  - если `perm_mask[k, i, j] = 0`, то i обращает внимание на j в батче k; - если `perm_mask[k, i, j] = 1`, то i не обращает внимание на j в батче k.  Если не задана, каждый токен обращает внимание на все остальные (полное двунаправленное внимание). Используется только во время предварительного обучения (для определения порядка факторизации) или при последовательном декодировании (генерации).

target_mapping (`torch.Tensor` формы `(batch_size, num_predict, sequence_length)`, *необязательный*) : Маска, указывающая, какие выходные токены следует использовать. Если `target_mapping[k, i, j] = 1`, то i-й предсказатель в батче k находится на j-м токене. Используется только во время предварительного обучения для частичного предсказания или последовательного декодирования (генерации).

token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`:  - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*.  [Что такое идентификаторы типов токенов?](../glossary#token-type-ids)

input_mask (`torch.Tensor` формы `batch_size, sequence_length`, *необязательный*) : Маска для исключения токенов отбивки из внимания. Отрицательное значение `attention_mask`, то есть 0 для реальных токенов и 1 для отбивки, что сохранено для совместимости с исходной кодовой базой. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **маскируются**, - 0 для токенов, которые **не маскируются**. Можно использовать только один из `input_mask` и `attention_mask`.

inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.

start_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) начала размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь.

end_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) конца размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь.

is_impossible (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки, указывающие, есть ли ответ на вопрос или его нет (SQuAD 2.0)

cls_index (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) токена классификации, используемого в качестве входа для вычисления правдоподобия ответа.

p_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Необязательная маска токенов, которые не могут входить в ответы (например, [CLS], [PAD], ...). 1.0 означает, что токен должен быть замаскирован. 0.0 означает, что токен не замаскирован.

use_mems (`bool`, *необязательный*) : Использовать ли состояния памяти для ускорения последовательного декодирования. Если установлено в `True`, модель будет использовать скрытые состояния из предыдущих проходов для вычисления внимания, что может значительно повысить производительность при задачах последовательного декодирования.

output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров.

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [XLNetForQuestionAnsweringOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput) или `tuple(torch.Tensor)`

Объект [XLNetForQuestionAnsweringOutput](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([XLNetConfig](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetConfig)) и входных данных.

Метод forward класса [XLNetForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/xlnet#transformers.XLNetForQuestionAnswering) переопределяет специальный метод `__call__`.

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если заданы и `start_positions`, и `end_positions`) — Потери классификации, представленные как сумма потерь классификации начального токена, конечного токена (а также is_impossible, если он задан).
- **start_top_log_probs** (`torch.Tensor` формы `(batch_size, config.start_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) -- Логарифмические вероятности для config.start_n_top наиболее вероятных стартовых токенов (поиск по лучам).
- **start_top_index** (`torch.LongTensor` формы `(batch_size, config.start_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не переданы) -- Индексы для config.start_n_top наиболее вероятных вариантов стартового токена (beam-search).
- **end_top_log_probs** (`torch.Tensor` формы `(batch_size, config.start_n_top * config.end_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) -- Логарифмические вероятности для топ-`config.start_n_top * config.end_n_top` вариантов конечных токенов (beam-search).
- **end_top_index** (`torch.LongTensor` формы `(batch_size, config.start_n_top * config.end_n_top)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не переданы) -- Индексы для топ-`config.start_n_top * config.end_n_top` вариантов конечных токенов (beam-search).
- **cls_logits** (`torch.Tensor` формы `(batch_size,)`, *необязательный*, возвращается, если `start_positions` или `end_positions` не указаны) -- Логарифмические вероятности для метки `is_impossible` ответов.
- **mems** (`list[torch.Tensor]` длиной `config.n_layers`) — содержит предварительно вычисленные скрытые состояния. Может использоваться (см. вход `mems`) для ускорения последовательного декодирования. Идентификаторы токенов, для которых прошлые состояния переданы в эту модель, не следует передавать как `input_ids`, поскольку они уже были вычислены.
- **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

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

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoTokenizer, XLNetForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")

>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)

>>> loss = outputs.loss
```

