# FlauBERT

## Обзор

Модель FlauBERT была предложена в статье [FlauBERT: Unsupervised Language Model Pre-training for French](https://huggingface.co/papers/1912.05372) авторами Hang Le и др. Это трансформерная модель, предварительно обученная с использованием задачи masked language modeling (MLM) (как в BERT).

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

*Языковые модели стали ключевым шагом к достижению передовых результатов во многих различных задачах обработки естественного языка (NLP). Используя огромный объём доступных в настоящее время размеченных текстов, они обеспечивают эффективный способ предварительного обучения непрерывных представлений слов, которые можно дообучить для конкретной задачи, а также их контекстуализации на уровне предложения. Это было широко продемонстрировано для английского языка с использованием контекстуализированных представлений (Dai and Le, 2015; Peters et al., 2018; Howard and Ruder, 2018; Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019b). В данной статье мы представляем и публикуем FlauBERT, модель, обученную на очень большом и гетерогенном французском корпусе. Модели разного размера обучаются с использованием нового суперкомпьютера Jean Zay, принадлежащего CNRS (Национальному центру научных исследований Франции). Мы применяем наши французские языковые модели к разнообразным задачам NLP (классификация текста, перефразирование, логический вывод на естественном языке, синтаксический разбор, разрешение неоднозначности значений слов) и показываем, что в большинстве случаев они превосходят другие подходы к предварительному обучению. Различные версии FlauBERT, а также единый протокол оценки для задач дообучения, называемый FLUE (French Language Understanding Evaluation), публикуются для исследовательского сообщества с целью проведения дальнейших воспроизводимых экспериментов во французском NLP.*

Эта модель была добавлена пользователем formiel. Исходный код можно найти [здесь](https://github.com/getalp/Flaubert).

Советы:

- Как и RoBERTa, без предсказания порядка предложений (то есть обучается только на задаче MLM).

## Ресурсы

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

## FlaubertConfig[[transformers.FlaubertConfig]]

#### transformers.FlaubertConfig[[transformers.FlaubertConfig]]

```python
transformers.FlaubertConfig(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, pre_norm: bool = False, layerdrop: float | int = 0.0, vocab_size: int = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, bos_index: int = 0, eos_index: int = 1, pad_index: int = 2, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True)
```

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

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

pre_norm (`bool`, *необязательный*, по умолчанию `False`) : Применяется ли нормализация слоя до или после слоя прямой передачи, следующего за слоем внимания в каждом слое (Vaswani et al., Tensor2Tensor for Neural Machine Translation. 2018)

layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556).

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

emb_dim (`int`, *optional*, по умолчанию 2048) : Размерность слоя встраиваний.

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

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

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

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

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

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

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

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

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

use_lang_emb (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли языковые эмбеддинги. Некоторые модели используют дополнительные языковые эмбеддинги, см. [страницу о мультиязычных моделях](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings) для информации об их использовании.

embed_init_std (`float`, *optional*, по умолчанию 2048^-0.5) : Стандартное отклонение truncated_normal_initializer для инициализации матриц эмбеддингов.

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

embed_init_std (`float`, *необязательный*, по умолчанию `2048**-0.5`) : Стандартное отклонение инициализатора для слоёв встраивания.

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

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

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

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

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

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

mask_index (`int`, *optional*, по умолчанию 5) : Индекс маскирующего токена в словаре.

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

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

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

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

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

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

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

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

mask_token_id (`int`, *optional*, по умолчанию 0) : Параметр, не зависящий от модели, для идентификации замаскированных токенов при генерации текста в контексте MLM.

lang_id (`int`, *optional*, по умолчанию 1) : Идентификатор языка, используемого моделью. Этот параметр применяется при генерации текста на заданном языке.

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

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

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

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

Это класс конфигурации для хранения настроек модели FlaubertModel. Он используется для создания модели Flaubert в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [flaubert/flaubert_base_uncased](https://huggingface.co/flaubert/flaubert_base_uncased)

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

## FlaubertTokenizer[[transformers.FlaubertTokenizer]]

#### transformers.FlaubertTokenizer[[transformers.FlaubertTokenizer]]

```python
transformers.FlaubertTokenizer(vocab_file, merges_file, do_lowercase = False, unk_token = '<unk>', bos_token = '<s>', sep_token = '</s>', pad_token = '<pad>', cls_token = '</s>', mask_token = '<special1>', additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>'], lang2id = None, id2lang = None, **kwargs)
```

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

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

vocab_file (`str`) : Файл словаря.

merges_file (`str`) : Объединяет файл.

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

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

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

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

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

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

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

additional_special_tokens (`List[str]`, *необязательный*, по умолчанию `['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']`) : Список дополнительных специальных токенов.

lang2id (`Dict[str, int]`, *необязательный*) : Словарь, сопоставляющий строковые идентификаторы языков с их ID.

id2lang (`Dict[int, str]`, *необязательный*) : Словарь, сопоставляющий идентификаторы языков их строковым идентификаторам.

Создаёт токенизатор Flaubert. Основан на байт-парной кодировке (Byte-Pair Encoding). Процесс токенизации выглядит следующим образом:

- Предобработка и токенизация Moses.
- Нормализация всех входных текстов.
- Аргумент `special_tokens` и функция `set_special_tokens` могут использоваться для добавления дополнительных символов (например, "__classify__") в словарь.
- Аргумент `do_lowercase` управляет приведением к нижнему регистру (автоматически устанавливается для предобученных словарей).

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

#### build_inputs_with_special_tokens[[transformers.FlaubertTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

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

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

token_ids_0 (`List[int]`) : Список идентификаторов, к которым будут добавлены специальные токены.

token_ids_1 (`List[int]`, *необязательный*) : Необязательный второй список идентификаторов для пар последовательностей.

**Возвращает:** `List[int]`

Список [идентификаторов входных токенов](../glossary#input-ids) с соответствующими специальными токенами.

Создайте входные данные модели из последовательности или пары последовательностей для задач классификации последовательностей, объединяя их и добавляя специальные токены. Последовательность XLM имеет следующий формат:

- одна последовательность: `<s> X </s>`
- пара последовательностей: `<s> A </s> B </s>`

#### convert_tokens_to_string[[transformers.FlaubertTokenizer.convert_tokens_to_string]]

```python
convert_tokens_to_string(tokens)
```

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

Преобразует последовательность токенов (строку) в одну строку.

#### get_special_tokens_mask[[transformers.FlaubertTokenizer.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/main/src/transformers/models/flaubert/tokenization_flaubert.py#L458)

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

token_ids_0 (`List[int]`) : Список идентификаторов.

token_ids_1 (`List[int]`, *необязательный*) : Необязательный второй список идентификаторов для пар последовательностей.

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

**Возвращает:** `List[int]`

Список целых чисел в диапазоне [0, 1]: 1 для специального токена, 0 для токена последовательности.

Получить идентификаторы последовательностей из списка токенов, в который не добавлены специальные токены. Этот метод вызывается при добавлении специальных токенов с помощью метода `prepare_for_model` токенизатора.

## FlaubertModel[[transformers.FlaubertModel]]

#### transformers.FlaubertModel[[transformers.FlaubertModel]]

```python
transformers.FlaubertModel(config: FlaubertConfig)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, lengths: typing.Optional[torch.LongTensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступны только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать `attention_mask` (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`:

cache (`dict[str, torch.Tensor]`, *необязательный*) : Словарь, сопоставляющий строки с `torch.Tensor`, содержащий предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания), полученные моделью (см. вывод `cache` ниже). Может использоваться для ускорения последовательного декодирования. Объект словаря будет изменяться на месте во время прямого прохода для добавления newly вычисленных скрытых состояний.

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

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

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

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

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

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

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

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

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

## FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]]

#### transformers.FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]]

```python
transformers.FlaubertWithLMHeadModel(config: FlaubertConfig)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertWithLMHeadModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступны только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать `attention_mask` (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`:

cache (`dict[str, torch.Tensor]`, *необязательный*) : Словарь, сопоставляющий строки с `torch.Tensor`, содержащий предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания), полученные моделью (см. вывод `cache` ниже). Может использоваться для ускорения последовательного декодирования. Объект словаря будет изменяться на месте во время прямого прохода для добавления newly вычисленных скрытых состояний.

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

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

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

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

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

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

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

Метод forward модели [FlaubertWithLMHeadModel](/docs/transformers/main/ru/model_doc/flaubert#transformers.FlaubertWithLMHeadModel) переопределяет специальный метод `__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, FlaubertWithLMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertWithLMHeadModel.from_pretrained("flaubert/flaubert_base_uncased")

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

## FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]]

#### transformers.FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]]

```python
transformers.FlaubertForSequenceClassification(config: FlaubertConfig)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступны только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать *attention_mask* (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *необязательный*) : Экземпляр `EncoderDecoderCache`, содержащий предварительно вычисленные KV-состояния. Может использоваться для ускорения последовательного декодирования.

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` — функция потерь классификации (кросс-энтропия).

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

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

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased")

>>> 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 = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", 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, FlaubertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", 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 = FlaubertForSequenceClassification.from_pretrained(
...     "flaubert/flaubert_base_uncased", 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
```

## FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]]

#### transformers.FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]]

```python
transformers.FlaubertForMultipleChoice(config: FlaubertConfig, *inputs, **kwargs)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступно только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать *attention_mask* (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *необязательный*) : Экземпляр `EncoderDecoderCache`, содержащий предварительно вычисленные KV-состояния. Может использоваться для ускорения последовательного декодирования.

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

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

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

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

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

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

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

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

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

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

  Оценки классификации (до 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, FlaubertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForMultipleChoice.from_pretrained("flaubert/flaubert_base_uncased")

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

## FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]]

#### transformers.FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]]

```python
transformers.FlaubertForTokenClassification(config: FlaubertConfig)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступны только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать *attention_mask* (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *необязательный*) : Экземпляр `EncoderDecoderCache`, содержащий предварительно вычисленные KV-состояния. Может использоваться для ускорения последовательного декодирования.

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

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

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

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

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

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

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForTokenClassification.from_pretrained("flaubert/flaubert_base_uncased")

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

## FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]]

#### transformers.FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]]

```python
transformers.FlaubertForQuestionAnsweringSimple(config: FlaubertConfig)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступны только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать *attention_mask* (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *необязательный*) : Экземпляр `EncoderDecoderCache`, содержащий предварительно вычисленные KV-состояния. Может использоваться для ускорения последовательного декодирования.

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`). Позиции вне последовательности не учитываются при вычислении функции потерь.

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

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

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForQuestionAnsweringSimple.from_pretrained("flaubert/flaubert_base_uncased")

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

## FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]]

#### transformers.FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]]

```python
transformers.FlaubertForQuestionAnswering(config: FlaubertConfig)
```

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

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

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

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

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

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

#### forward[[transformers.FlaubertForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

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

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

langs (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Параллельная последовательность токенов, используемая для указания языка каждого токена во входных данных. Индексы представляют собой идентификаторы языков, которые можно получить из названий языков с помощью двух карт преобразования, предоставленных в конфигурации модели (доступны только для многоязычных моделей). Более точно, карта *название языка в идентификатор языка* находится в `model.config.lang2id` (это словарь из строк в целые числа), а карта *идентификатор языка в название языка* — в `model.config.id2lang` (словарь из целых чисел в строки). Примеры использования подробно описаны в [документации по многоязычности](../multilingual).

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

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

lengths (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Длина каждого предложения, которую можно использовать, чтобы избежать применения внимания к индексам токенов отсечки. Для достижения того же результата можно также использовать *attention_mask* (см. выше); параметр сохранён здесь ради совместимости. Индексы выбираются из диапазона `[0, ..., input_ids.size(-1)]`.

cache (`dict[str, torch.Tensor]`, *необязательный*) : Экземпляр `EncoderDecoderCache`, содержащий предварительно вычисленные KV-состояния. Может использоваться для ускорения последовательного декодирования.

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 означает, что токен не замаскирован.

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

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

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

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

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

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = FlaubertForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

