# Reformer

## Обзор

Модель Reformer была предложена в статье [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451) Никитой Китеевым, Лукашем Кайзером и Анселем Левскаей.

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

*Крупные модели Transformer регулярно демонстрируют наилучшие результаты по ряду задач, однако обучение таких моделей может быть чрезмерно затратным, особенно на длинных последовательностях. Мы предлагаем две техники для повышения эффективности Transformer. Во-первых, мы заменяем внимание на основе скалярного произведения на внимание, использующее хеширование с учётом локальности, что изменяет его сложность с O(L^2) до O(Llog(L)), где L — длина последовательности. Кроме того, мы используем обратимые остаточные слои вместо стандартных остаточных связей, что позволяет хранить активации лишь один раз в процессе обучения, а не N раз, где N — количество слоёв. Полученная модель, Reformer, показывает результаты, сопоставимые с моделями Transformer, при этом значительно более эффективно используя память и значительно быстрее обучаясь на длинных последовательностях.*

Эта модель была предоставлена пользователем [patrickvonplaten](https://huggingface.co/patrickvonplaten). Код авторов можно найти [здесь](https://github.com/google/trax/tree/master/trax/models/reformer).

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

- Reformer **не** работает с *torch.nn.DataParallel* из-за ошибки в PyTorch, см. [issue #36035](https://github.com/pytorch/pytorch/issues/36035).
- Используйте кодирование осевой позиции (см. ниже для получения подробной информации). Это механизм, позволяющий избежать создания огромной матрицы позиционного кодирования (когда длина последовательности очень велика) путём её факторизации на более мелкие матрицы.
- Замените традиционное внимание на внимание LSH (local-sensitive hashing) (подробнее см. ниже). Это техника, позволяющая избежать вычисления полного произведения query-key в слоях внимания.
- Чтобы избежать хранения промежуточных результатов каждого слоя, используйте обратимые слои трансформера, чтобы получить их во время обратного прохода (вычитание остатков из входа следующего слоя позволяет восстановить их) или пересчитывайте их для результатов внутри данного слоя (менее эффективно, чем хранение, но экономит память).
- Выполняйте операции feedforward по частям, а не на всей выборке.

### Позиционные кодировки по осям

Позиционные кодировки Axial Positional Encodings впервые были реализованы в библиотеке [trax](https://github.com/google/trax/blob/4d99ad4965bab1deba227539758d59f0df0fef48/trax/layers/research/position_encodings.py#L29) от Google и разработаны авторами статьи, посвящённой данной модели. В моделях, обрабатывающих очень длинные входные последовательности, традиционные кодировки идентификаторов позиций хранят вектор эмбеддингов размера $d$, равный `config.hidden_size`, для каждой позиции $i, \ldots, n_s$, где $n_s$ — это `config.max_embedding_size`. Это означает, что при длине последовательности $n_s = 2^{19} \approx 0.5M$ и значении `config.hidden_size` $d = 2^{10} \approx 1000$ матрица позиционных кодировок будет иметь следующий вид:

$$X_{i,j}, \text{ где } i \in \left[1,\ldots, d\right] \text{ и } j \in \left[1,\ldots, n_s\right]$$

который сам по себе содержит более 500 млн параметров для хранения. Осевые позиционные кодирования факторизуют $X_{i,j}$ в две матрицы:

$$X^{1}_{i,j}, \text{ где } i \in \left[1,\ldots, d^1\right] \text{ и } j \in \left[1,\ldots, n_s^1\right]$$

и

$$X^{2}_{i,j}, \text{ где } i \in \left[1,\ldots, d^2\right] \text{ и } j \in \left[1,\ldots, n_s^2\right]$$

с:

$$d = d^1 + d^2 \text{ and } n_s = n_s^1 \times n_s^2 .$$

Следовательно, выполняется следующее:

$$X_{i,j} = \begin{cases} X^{1}_{i, k}, & \text{if }\ i < d^1 \text{ with } k = j \mod n_s^1 \\ X^{2}_{i - d^1, l}, & \text{if } i \ge d^1 \text{ with } l = \lfloor\frac{j}{n_s^1}\rfloor \end{cases}$$

Интуитивно это означает, что вектор позиционного эмбеддинга $x_j \in \mathbb{R}^{d}$ теперь представляет собой композицию двух факторизованных векторов эмбеддингов: $x^1_{k, l} + x^2_{l, k}$, где размерность $j$ из `config.max_embedding_size` факторизуется в $k \text{ и } l$. Такой подход гарантирует, что каждый вектор позиционного эмбеддинга $x_j$ является уникальным.

Используя тот же пример, аксиальное позиционное кодирование с $d^1 = 2^9, d^2 = 2^9, n_s^1 = 2^9, n_s^2 = 2^{10}$ может резко сократить количество параметров с 500 000 000 до $2^{18} + 2^{19} \approx 780 000$ параметров, что означает снижение потребления памяти на 85%.

На практике параметр `config.axial_pos_embds_dim` задается кортежем $(d^1, d^2)$, сумма элементов которого должна быть равна `config.hidden_size`, а `config.axial_pos_shape` — кортежем $(n_s^1, n_s^2)$, произведение элементов которого должно быть равно `config.max_embedding_size`, который в процессе обучения должен совпадать с *длиной последовательности* `input_ids`.

### LSH Self Attention

In Locality sensitive hashing (LSH) self attention the key and query projection weights are tied. Therefore, the key query embedding vectors are also tied. LSH self attention uses the locality sensitive hashing mechanism proposed in [Practical and Optimal LSH for Angular Distance](https://huggingface.co/papers/1509.02897) to assign each of the tied key query embedding vectors to one of `config.num_buckets` possible buckets. The premise is that the more "similar" key query embedding vectors (in terms of *cosine similarity*) are to each other, the more likely they are assigned to the same bucket.

Точность механизма LSH можно повысить, увеличив `config.num_hashes` или непосредственно аргумент `num_hashes` функции forward, чтобы выход LSH self attention лучше аппроксимировал выход «обычного» полного self attention. Затем бакеты сортируются и разбиваются на чанки векторов эмбеддингов query и key, каждый из которых имеет длину `config.lsh_chunk_length`. Для каждого чанка векторы эмбеддингов query обращаются к своим векторам key (которые связаны с собой) и к векторам эмбеддингов key из `config.lsh_num_chunks_before` предыдущих соседних чанков и `config.lsh_num_chunks_after` последующих соседних чанков.

Для получения дополнительной информации см. [оригинальную статью](https://huggingface.co/papers/2001.04451) или эту отличную [статью в блоге](https://www.pragmatic.ml/reformer-deep-dive/).

Обратите внимание, что `config.num_buckets` также может быть разложено в список $(n_{\text{buckets}}^1, n_{\text{buckets}}^2)$. Таким образом, векторы встраиваний ключей запросов назначаются не одному из $(1,\ldots, n_{\text{buckets}})$, а одному из $(1-1,\ldots, n_{\text{buckets}}^1-1, \ldots, 1-n_{\text{buckets}}^2, \ldots, n_{\text{buckets}}^1-n_{\text{buckets}}^2)$. Это критически важно для очень длинных последовательностей, чтобы сэкономить память.

При обучении модели с нуля рекомендуется оставить `config.num_buckets=None`, чтобы в зависимости от длины последовательности хорошее значение для `num_buckets` рассчитывалось на лету. Это значение затем автоматически сохраняется в конфигурации и должно использоваться при инференсе.

Используя само-внимание LSH, память и временну́ю сложность операции матричного умножения query-key можно снизить с $\mathcal{O}(n_s \times n_s)$ до $\mathcal{O}(n_s \times \log(n_s))$, что обычно является узким местом по памяти и времени в трансформерной модели, где $n_s$ — длина последовательности.

### Локальное само-внимание

Локальное само-внимание по сути представляет собой «обычный» слой само-внимания с проекциями ключей, запросов и значений, но он разбит на блоки так, что в каждом блоке длины `config.local_chunk_length` векторы запросов обращаются только к векторам ключей в своём блоке, а также к векторам ключей в `config.local_num_chunks_before` предыдущих соседних блоках и `config.local_num_chunks_after` последующих соседних блоках.

Используя локальное само-внимание, память и временну́ю сложность операции матричного умножения query-key можно снизить с $\mathcal{O}(n_s \times n_s)$ до $\mathcal{O}(n_s \times \log(n_s))$, что обычно является узким местом по памяти и времени в трансформерной модели, где $n_s$ — длина последовательности.

### Обучение

В процессе обучения необходимо убедиться, что длина последовательности установлена в значение, кратное наименьшему общему кратному `config.lsh_chunk_length` и `config.local_chunk_length`, а параметры Axial Positional Encodings настроены корректно, как описано выше. Reformer обладает высокой эффективностью использования памяти, что позволяет легко обучать модель на последовательностях длиной до 64000 токенов.

Для обучения модель [ReformerModelWithLMHead](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerModelWithLMHead) следует использовать следующим образом:

```python
input_ids = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device)
loss = model(input_ids, labels=input_ids)[0]
```

## Ресурсы

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

## ReformerConfig[[transformers.ReformerConfig]]

#### transformers.ReformerConfig[[transformers.ReformerConfig]]

```python
transformers.ReformerConfig(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, attention_head_size: int = 64, attn_layers: list[str] | tuple[str, ...] = ('local', 'lsh', 'local', 'lsh', 'local', 'lsh'), axial_norm_std: float = 1.0, axial_pos_embds: bool = True, axial_pos_shape: list[int] | tuple[int, ...] = (64, 64), axial_pos_embds_dim: list[int] | tuple[int, ...] = (64, 192), chunk_size_lm_head: int = 0, eos_token_id: int | list[int] | None = 2, feed_forward_size: int = 512, hash_seed: int | None = None, hidden_act: str = 'relu', hidden_dropout_prob: float | int = 0.05, hidden_size: int = 256, initializer_range: float = 0.02, is_decoder: bool = False, layer_norm_eps: float = 1e-12, local_num_chunks_before: int = 1, local_num_chunks_after: int = 0, local_attention_probs_dropout_prob: float | int = 0.05, local_attn_chunk_length: int = 64, lsh_attn_chunk_length: int | None = 64, lsh_attention_probs_dropout_prob: float | None = 0.0, lsh_num_chunks_before: int | None = 1, lsh_num_chunks_after: int | None = 0, max_position_embeddings: int = 4096, num_attention_heads: int = 12, num_buckets: int | list[int] | None = None, num_hashes: int = 1, vocab_size: int = 320, tie_word_embeddings: bool = False, use_cache: bool = True, classifier_dropout: float | int | None = None, bos_token_id: int | None = None, pad_token_id: int | None = 0)
```

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

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

attention_head_size (`int`, *optional*, по умолчанию 64) : Размерность проекционных векторов ключей, запросов и значений

attn_layers (`list[str]`, *необязательный*, по умолчанию `["local", "lsh", "local", "lsh", "local", "lsh"]`) : Список типов слоев внимания в порядке возрастания. Можно выбрать между слоем LSHSelfAttention (`"lsh"`) и слоем LocalSelfAttention (`"local"`). Подробнее о слое LSHSelfAttention см. [LSH Self Attention](reformer#lsh-self-attention). Подробнее о слое LocalSelfAttention см. [Local Self Attention](reformer#local-self-attention).

axial_norm_std (`float`, *optional*, по умолчанию 1.0) : Стандартное отклонение normal_initializer для инициализации весовых матриц осевых позиционных кодировок.

axial_pos_embds (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли осевые позиционные эмбеддинги. Подробнее о том, как работают осевые позиционные эмбеддинги, см. [Axial Position Encodings](reformer#axial-positional-encodings).

axial_pos_shape (`list[int]`, *optional*, по умолчанию `[64, 64]`) : Размерности позиций для аксиальных позиционных кодировок. Во время обучения произведение размерностей позиций должно быть равно длине последовательности. Подробнее о том, как работают аксиальные позиционные эмбеддинги, см. [Axial Position Encodings](reformer#axial-positional-encodings).

axial_pos_embds_dim (`list[int]`, *optional*, по умолчанию `[64, 192]`) : Размеры эмбеддингов для осевых позиционных кодировок. Сумма размеров эмбеддингов должна быть равна размеру скрытого слоя. Подробнее о том, как работают осевые позиционные эмбеддинги, см. [Axial Position Encodings](reformer#axial-positional-encodings).

chunk_size_lm_head (`int`, *optional*, по умолчанию 0) : Размер блока для конечного слоя прямой передачи языковой модели. Размер блока 0 означает, что слой прямой передачи не разбивается на блоки. Размер блока n означает, что слой прямой передачи обрабатывает n < sequence_length эмбеддингов за один раз. Подробнее о разбиении слоя прямой передачи на блоки см. в разделе [Как работает разбиение слоя прямой передачи на блоки?](../glossary#feed-forward-chunking).

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

feed_forward_size (`int`, *optional*, по умолчанию 512) : Размерность слоя feed_forward в блоке остаточного внимания.

hash_seed (`int`, *optional*) : Значение seed, которое можно использовать для обеспечения детерминированности локального чувствительного хеширования в `LSHSelfAttention`. Это поле следует задавать только для целей тестирования. Для оценки и обучения `hash_seed` следует оставить равным `None`, чтобы гарантировать полностью случайные вращения в схеме локального чувствительного хеширования.

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

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

hidden_size (`int`, *optional*, по умолчанию `256`) : Размерность скрытых представлений.

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

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

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

local_num_chunks_before (`int`, *optional*, по умолчанию 1) : Количество предыдущих соседних чанков, на которые обращает внимание слой `LocalSelfAttention`.

local_num_chunks_after (`int`, *optional*, по умолчанию 0) : Количество последующих соседних чанков, на которые обращает внимание слой `LocalSelfAttention` в дополнение к самому себе.

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

local_attn_chunk_length (`int`, *необязательный*, по умолчанию 64) : Длина каждого фрагмента в слоях локального внимания.

lsh_attn_chunk_length (`int`, *optional*, по умолчанию 64) : Длина фрагмента, который обращается к самому себе в `LSHSelfAttention`. Разбиение на фрагменты снижает сложность по памяти с длины последовательности x длина последовательности (само-внимание) до длины фрагмента x длина фрагмента x длина последовательности / длина фрагмента (фрагментированное само-внимание).

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

lsh_num_chunks_before (`int`, *optional*, по умолчанию 1) : Количество предыдущих соседних чанков, на которые обращает внимание слой `LSHSelfAttention` в отношении самого себя.

lsh_num_chunks_after (`int`, *optional*, по умолчанию 0) : Количество следующих соседних чанков, на которые слой `LSHSelfAttention` обращает внимание в отношении самого себя.

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

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

num_buckets (`int` или `list[int]`, *необязательный*) : Количество бакетов, в которые векторы ключей запросов могут быть «хэшированы» с использованием схемы локально-чувствительного хэширования. Каждый вектор ключа запроса хэшируется в значение из диапазона `1, ..., num_buckets`. Количество бакетов также можно разложить на список множителей для улучшения сложности по памяти. В этом случае каждый вектор ключа запроса хэшируется в значение из диапазона `1-1, 1-2, ..., num_buckets[0]-1, ..., num_buckets[0]-num_buckets[1]`, если `num_buckets` разложено на два множителя. Количество бакетов (или произведение множителей) должно приблизительно равняться длине последовательности / lsh_chunk_length. Если `num_buckets` не задано, хорошее значение вычисляется на лету.

num_hashes (`int`, *optional*, по умолчанию 1) : Количество раундов хеширования (например, количество случайных поворотов) в схеме локально чувствительного хеширования. Чем выше значение `num_hashes`, тем точнее становится `LSHSelfAttention`, но тем больше памяти и времени требует процесс хеширования.

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

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

use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером.

classifier_dropout (`Union[float, int]`, *необязательный*) : Коэффициент dropout для классификатора.

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

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

Это класс конфигурации для хранения настроек модели ReformerModel. Он используется для создания модели Reformer в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [google/reformer-crime-and-punishment](https://huggingface.co/google/reformer-crime-and-punishment)

Объекты конфигурации наследуются от [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 ReformerConfig, ReformerModel

>>> # Initializing a Reformer configuration
>>> configuration = ReformerConfig()

>>> # Initializing a Reformer model (with random weights)
>>> model = ReformerModel(configuration)

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

## ReformerTokenizer[[transformers.ReformerTokenizer]]

#### transformers.ReformerTokenizer[[transformers.ReformerTokenizer]]

```python
transformers.ReformerTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, eos_token: str = '</s>', unk_token: str = '<unk>', _spm_precompiled_charsmap: str | None = None, additional_special_tokens: list | None = None, **kwargs)
```

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

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

vocab_file (`str`) : файл [SentencePiece](https://github.com/google/sentencepiece) (обычно имеет расширение *.spm*), содержащий словарь, необходимый для создания токенизатора.

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

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

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

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

vocab (`str` или `dict[str, int]`, *необязательный*) : Пользовательский словарь. Если не указан, словарь загружается из `vocab_file`.

merges (`str` или `list[str]`, *необязательный*) : Пользовательский список слияний. Если не указан, слияния загружаются из `vocab_file`.

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

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

#### save_vocabulary[[transformers.ReformerTokenizer.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)

## ReformerModel[[transformers.ReformerModel]]

#### transformers.ReformerModel[[transformers.ReformerModel]]

```python
transformers.ReformerModel(config: ReformerConfig)
```

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

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

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

Модель Reformer без дополнительных слоёв, выводящая необработанные скрытые состояния.

Эта модель наследуется от [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.ReformerModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: transformers.models.reformer.modeling_reformer.ReformerDynamicCache | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Во время обучения sequence_length для input_ids должна быть кратна соответствующим длинам чанков модели (lsh, local или обоим). Во время оценки индексы автоматически дополняются до кратного значения длины чанка. Индексы можно получить с помощью [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)

position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое идентификаторы позиций?](../glossary#position-ids)

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

num_hashes (`int`, *optional*) : Количество раундов хеширования, которое должно выполняться при.bucketing. Установка этого аргумента переопределяет значение по умолчанию, заданное в `config.num_hashes`.  Подробнее см. `num_hashes` в [ReformerConfig](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerConfig).

past_buckets_states (`ReformerDynamicCache`, *optional*) : Список `tuple(torch.LongTensor, torch.Tensor` длины `config.n_layers`, где первый элемент — предыдущие *buckets* формы `(batch_size, num_heads, num_hashes, sequence_length)`, а второй — предыдущие *hidden_states* формы `(batch_size, sequence_length, hidden_size)`). Содержит предварительно вычисленные hidden-states и buckets (актуально только для LSH Self-Attention). Может использоваться для ускорения последовательного декодирования.

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

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

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

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

**Возвращает:** `ReformerModelOutput` или `tuple(torch.Tensor)`

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

Метод forward модели [ReformerModel](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerModel) переопределяет специальный метод `__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`.
- **past_buckets_states** (`list[tuple(torch.LongTensor, torch.Tensor)]`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- Список `tuple(torch.LongTensor, torch.Tensor` длины `config.n_layers`, где первый элемент — предыдущие *buckets* формы `(batch_size, num_heads, num_hashes, sequence_length)`), а второй — предыдущие *hidden_states* формы `(batch_size, sequence_length, hidden_size)`).

  Содержит предварительно вычисленные бакеты и скрытые состояния, которые можно использовать (см. вход `past_buckets_states`) для ускорения последовательного декодирования.
- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

#### transformers.ReformerModelWithLMHead[[transformers.ReformerModelWithLMHead]]

```python
transformers.ReformerModelWithLMHead(config: ReformerConfig)
```

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

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

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

Модель Reformer с головкой `language modeling` наверху.

Эта модель наследуется от [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.ReformerModelWithLMHead.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, past_buckets_states: list[tuple[torch.Tensor]] | None = None, use_cache: bool | None = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

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

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Во время обучения sequence_length для input_ids должна быть кратна соответствующим длинам чанков модели (lsh, local или обоим). Во время оценки индексы автоматически дополняются до кратного значения длины чанка. Индексы можно получить с помощью [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)

position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое идентификаторы позиций?](../glossary#position-ids)

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

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

num_hashes (`int`, *optional*) : Количество раундов хеширования, которое должно выполняться при.bucketing. Установка этого аргумента переопределяет значение по умолчанию, заданное в `config.num_hashes`.  Подробнее см. `num_hashes` в [ReformerConfig](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerConfig).

past_buckets_states (`list[tuple(torch.LongTensor, torch.Tensor)]`, *необязательный*) : Список `tuple(torch.LongTensor, torch.Tensor` длины `config.n_layers`, где первый элемент — предыдущие *buckets* формы `(batch_size, num_heads, num_hashes, sequence_length)`, а второй — предыдущие *hidden_states* формы `(batch_size, sequence_length, hidden_size)`). Содержит предварительно вычисленные скрытые состояния и бакеты (актуально только для LSH Self-Attention). Может использоваться для ускорения последовательного декодирования.

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

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

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

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

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

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

**Возвращает:** [CausalLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutput) или `tuple(torch.Tensor)`

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerModelWithLMHead.from_pretrained("google/reformer-crime-and-punishment")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

#### transformers.ReformerForMaskedLM[[transformers.ReformerForMaskedLM]]

```python
transformers.ReformerForMaskedLM(config: ReformerConfig)
```

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

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

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

Модель Reformer с головой `language modeling` сверху."

Эта модель наследуется от [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.ReformerForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Во время обучения sequence_length для input_ids должна быть кратна соответствующим длинам чанков модели (lsh, local или обоим). Во время оценки индексы автоматически дополняются до кратного значения длины чанка. Индексы можно получить с помощью [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)

position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое идентификаторы позиций?](../glossary#position-ids)

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

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

num_hashes (`int`, *optional*) : Количество раундов хеширования, которое должно выполняться при.bucketing. Установка этого аргумента переопределяет значение по умолчанию, заданное в `config.num_hashes`.  Подробнее см. `num_hashes` в [ReformerConfig](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerConfig).

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

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

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

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

**Возвращает:** [MaskedLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) или `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери маскированного языкового моделирования (MLM).
- **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax).
- **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, ReformerForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-reformer")
>>> model = ReformerForMaskedLM.from_pretrained("hf-internal-testing/tiny-random-reformer")

>>> # add mask_token
>>> tokenizer.add_special_tokens({"mask_token": "[MASK]"})
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> # resize model's embedding matrix
>>> model.resize_token_embeddings(new_num_tokens=model.config.vocab_size + 1)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> predicted_token = tokenizer.decode(predicted_token_id)
```

```python
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(
...     inputs.input_ids == tokenizer.mask_token_id, labels[:, : inputs["input_ids"].shape[-1]], -100
... )

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

## ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

#### transformers.ReformerForSequenceClassification[[transformers.ReformerForSequenceClassification]]

```python
transformers.ReformerForSequenceClassification(config: ReformerConfig)
```

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

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

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

Reformer Модель transformer с головой для классификации/регрессии последовательности (линейный слой поверх пуллинг-выхода), например, для задач 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.ReformerForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Во время обучения sequence_length для input_ids должна быть кратна соответствующим длинам чанков модели (lsh, local или обоим). Во время оценки индексы автоматически дополняются до кратного значения длины чанка. Индексы можно получить с помощью [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)

position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое идентификаторы позиций?](../glossary#position-ids)

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

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

num_hashes (`int`, *optional*) : Количество раундов хеширования, которое должно выполняться при.bucketing. Установка этого аргумента переопределяет значение по умолчанию, заданное в `config.num_hashes`.  Подробнее см. `num_hashes` в [ReformerConfig](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerConfig).

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

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

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

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

**Возвращает:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1).
- **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax.
- **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, ReformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForSequenceClassification.from_pretrained("google/reformer-crime-and-punishment")

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

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

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

```python
>>> # 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 = ReformerForSequenceClassification.from_pretrained(
...     "google/reformer-crime-and-punishment", num_labels=num_labels
... )

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
```

## ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

#### transformers.ReformerForQuestionAnswering[[transformers.ReformerForQuestionAnswering]]

```python
transformers.ReformerForQuestionAnswering(config: ReformerConfig)
```

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

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

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

Трансформер Reformer с головой для классификации пропусков (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.ReformerForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, num_hashes: int | None = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, output_attentions: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`) : Индексы токенов входной последовательности в словаре. Во время обучения sequence_length для input_ids должна быть кратна соответствующим длинам чанков модели (lsh, local или обоим). Во время оценки индексы автоматически дополняются до кратного значения длины чанка. Индексы можно получить с помощью [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)

position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое идентификаторы позиций?](../glossary#position-ids)

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

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

num_hashes (`int`, *optional*) : Количество раундов хеширования, которое должно выполняться при.bucketing. Установка этого аргумента переопределяет значение по умолчанию, заданное в `config.num_hashes`.  Подробнее см. `num_hashes` в [ReformerConfig](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerConfig).

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

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

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

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

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

**Возвращает:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) или `tuple(torch.Tensor)`

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

Метод forward класса [ReformerForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/reformer#transformers.ReformerForQuestionAnswering) переопределяет специальный метод `__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).
- **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, ReformerForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/reformer-crime-and-punishment")
>>> model = ReformerForQuestionAnswering.from_pretrained("google/reformer-crime-and-punishment")

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

