# ERNIE [ERNIE1.0](https://huggingface.co/papers/1904.09223), [ERNIE2.0](https://ojs.aaai.org/index.php/AAAI/article/view/6428), [ERNIE3.0](https://huggingface.co/papers/2107.02137), [ERNIE-Gram](https://huggingface.co/papers/2010.12148), [ERNIE-health](https://huggingface.co/papers/2110.07244) — это серия мощных моделей, предложенных baidu, особенно эффективных в китайских задачах. ERNIE (Enhanced Representation through kNowledge IntEgration) предназначен для обучения языковым представлениям, усиленным стратегиями маскирования знаний, включая маскирование на уровне сущностей и на уровне фраз. Другие модели ERNIE, выпущенные baidu, можно найти по ссылкам [Ernie 4.5](./ernie4_5) и [Ernie 4.5 MoE](./ernie4_5_moe). > [!TIP] > Эта модель была предоставлена [nghuyong](https://huggingface.co/nghuyong), а официальный код можно найти в [PaddleNLP](https://github.com/PaddlePaddle/PaddleNLP) (в PaddlePaddle). > > Щёлкните по моделям ERNIE в боковой панели справа, чтобы увидеть больше примеров применения ERNIE к различным языковым задачам. Приведённый ниже пример показывает, как предсказать токен `[MASK]` с помощью [Pipeline](/docs/transformers/v5.23.0/ru/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoModel) и из командной строки. ```python from transformers import pipeline pipeline = pipeline( task="fill-mask", model="nghuyong/ernie-3.0-xbase-zh" ) pipeline("巴黎是[MASK]国的首都。") ``` ```python import torch from transformers import AutoModelForMaskedLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained( "nghuyong/ernie-3.0-xbase-zh", ) model = AutoModelForMaskedLM.from_pretrained( "nghuyong/ernie-3.0-xbase-zh", device_map="auto" ) inputs = tokenizer("巴黎是[MASK]国的首都。", return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) predictions = outputs.logits masked_index = torch.where(inputs['input_ids'] == tokenizer.mask_token_id)[1] predicted_token_id = predictions[0, masked_index].argmax(dim=-1) predicted_token = tokenizer.decode(predicted_token_id) print(f"The predicted token is: {predicted_token}") ``` ## Примечания Варианты моделей доступны в разных размерах и на разных языках. | Название модели | Язык | Описание | |:-------------------:|:--------:|:-------------------------------:| | ernie-1.0-base-zh | Китайский | Слой:12, Головок:12, Скрытое:768 | | ernie-2.0-base-en | English | Слой:12, Головок:12, Скрытое:768 | | ernie-2.0-large-en | English | Слой:24, Головок:16, Скрытое:1024 | | ernie-3.0-base-zh | Китайский | Слой:12, Головок:12, Скрытое:768 | | ernie-3.0-medium-zh | Китайский | Слой:6, Головок:12, Скрытое:768 | | ernie-3.0-mini-zh | Китайский | Слои:6, Головки:12, Скрытые:384 | | ernie-3.0-micro-zh | Китайский | Слой:4, Головок:12, Скрытое:384 | | ernie-3.0-nano-zh | Китайский | Слой:4, Головок:12, Скрытое:312 | | ernie-health-zh | Китайский | Слой:12, Головок:12, Скрытое:768 | | ernie-gram-zh | Китайский | Слой:12, Головок:12, Скрытое:768 | ## Ресурсы Все поддерживаемые модели можно найти в модельном хабе huggingface: [huggingface.co/nghuyong](https://huggingface.co/nghuyong), а подробности о моделях — в официальном репозитории paddle: [PaddleNLP](https://paddlenlp.readthedocs.io/zh/latest/model_zoo/transformers/ERNIE/contents.html) и [устаревшая ветка ERNIE](https://github.com/PaddlePaddle/ERNIE/tree/legacy/develop). ## ErnieConfig[[transformers.ErnieConfig]] #### transformers.ErnieConfig[[transformers.ErnieConfig]] ```python transformers.ErnieConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, task_type_vocab_size: int = 3, use_task_id: bool = False, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, use_cache: bool = True, classifier_dropout: float | int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/configuration_ernie.py#L25) **Параметры:** vocab_size (`int`, *необязательный*, по умолчанию `30522`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`. hidden_size (`int`, *optional*, по умолчанию `768`) : Размерность скрытых представлений. num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer. num_attention_heads (`int`, *необязательный*, по умолчанию `12`) : Количество головок внимания для каждого слоя внимания в декодере Transformer. intermediate_size (`int`, *optional*, по умолчанию `3072`) : Размерность представлений MLP. hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. hidden_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Вероятность dropout для всех полносвязных слоев в эмбеддингах, энкодере и пулере. attention_probs_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания. max_position_embeddings (`int`, *необязательный*, по умолчанию `512`) : Максимальная длина последовательности, с которой может использоваться данная модель. type_vocab_size (`int`, *необязательный*, по умолчанию `2`) : Размер словаря для `token_type_ids`. task_type_vocab_size (`int`, *optional*, по умолчанию 3) : Размер словаря для `task_type_ids` в модели ERNIE2.0/ERNIE3.0 use_task_id (`bool`, *необязательный*, по умолчанию `False`) : Поддерживает ли модель `task_type_ids` initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-12`) : Значение epsilon, используемое слоями нормализации. pad_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для выравнивания в словаре. use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером. classifier_dropout (`Union[float, int]`, *необязательный*) : Коэффициент dropout для классификатора. is_decoder (`bool`, *необязательный*, по умолчанию `False`) : Указывает, используется ли модель в качестве декодера. Если `False`, модель используется как энкодер. add_cross_attention (`bool`, *необязательный*, по умолчанию `False`) : Следует ли добавлять слои кросс-внимания в модель. bos_token_id (`int`, *optional*) : Идентификатор токена, используемый для обозначения начала потока в словаре. eos_token_id (`Union[int, list[int]]`, *необязательный*) : Идентификатор токена, используемый для обозначения конца потока в словаре. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. Это класс конфигурации для хранения настроек модели ErnieModel. Он используется для создания модели Ernie в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [nghuyong/ernie-3.0-base-zh](https://huggingface.co/nghuyong/ernie-3.0-base-zh) Объекты конфигурации наследуются от [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 ErnieConfig, ErnieModel >>> # Initializing a ERNIE nghuyong/ernie-3.0-base-zh style configuration >>> configuration = ErnieConfig() >>> # Initializing a model (with random weights) from the nghuyong/ernie-3.0-base-zh style configuration >>> model = ErnieModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Специфические для Ernie выходные данные[[transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput]] #### transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput[[transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput]] ```python transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, prediction_logits: typing.Optional[torch.Tensor] = None, seq_relationship_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L698) **Параметры:** loss (`*optional*`, возвращается, если предоставлено `labels`, `torch.Tensor` формы `(1,)`) : Суммарная потеря, равная сумме потерь маскированного языкового моделирования и потери классификации для предсказания следующего последовательности. prediction_logits (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) : Оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax). seq_relationship_logits (`torch.Tensor` формы `(batch_size, 2)`) : Оценки предсказания следующего последовательного предсказания (классификации) (оценки продолжения True/False до 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-функции внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Тип выходных данных [ErnieForPreTraining](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForPreTraining). ## ErnieModel[[transformers.ErnieModel]] #### transformers.ErnieModel[[transformers.ErnieModel]] ```python transformers.ErnieModel(config: ErnieConfig, add_pooling_layer = True) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L556) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. add_pooling_layer (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли добавлять слой пулинга Модель может работать как в режиме энкодера (с использованием только self-attention), так и в режиме декодера, в котором между слоями self-attention добавляется слой cross-attention, в соответствии с архитектурой, описанной в статье [Attention is all you need](https://huggingface.co/papers/1706.03762) авторов Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser и Illia Polosukhin. Чтобы модель работала как декодер, её необходимо инициализировать с аргументом `is_decoder` конфигурации, установленным в `True`. Для использования в модели Seq2Seq модель должна быть инициализирована с аргументами `is_decoder` и `add_cross_attention`, установленными в `True`; в этом случае в качестве входа для прямого прохода ожидается `encoder_hidden_states`. Эта модель наследуется от [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.ErnieModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L582) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер. encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). **Возвращает:** [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) или `tuple(torch.Tensor)` Объект [BaseModelOutputWithPoolingAndCrossAttentions](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод forward модели [ErnieModel](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения. - **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` и `config.add_cross_attention=True` или если `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кросс-внимания декодера, после применения softmax к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и, при необходимости, если `config.is_encoder_decoder=True`, в блоках кросс-внимания), которые можно использовать (см. входной параметр `past_key_values`) для ускорения последовательного декодирования. ## ErnieForPreTraining[[transformers.ErnieForPreTraining]] #### transformers.ErnieForPreTraining[[transformers.ErnieForPreTraining]] ```python transformers.ErnieForPreTraining(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L735) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Ernie с двумя головками сверху, как это было сделано во время предварительного обучения: головка `masked language modeling` и головка `next sentence prediction (classification)`. Эта модель наследуется от [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.ErnieForPreTraining.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, next_sentence_label: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L757) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]` next_sentence_label (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь предсказания следующей последовательности (классификации). Вход должен представлять собой пару последовательностей (см. строку документации `input_ids`). Индексы должны находиться в диапазоне `[0, 1]`: - 0 означает, что последовательность B является продолжением последовательности A, - 1 означает, что последовательность B является случайной последовательностью. **Возвращает:** [ErnieForPreTrainingOutput](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput) или `tuple(torch.Tensor)` Объект [ErnieForPreTrainingOutput](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод forward класса [ErnieForPreTraining](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForPreTraining) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`*optional*`, возвращается, если задан `labels`, `torch.Tensor` формы `(1,)`) -- Суммарная потеря, равная сумме потерь маскированного языкового моделирования и потери классификации для предсказания следующего последовательности. - **prediction_logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax). - **seq_relationship_logits** (`torch.Tensor` формы `(batch_size, 2)`) -- Оценки предсказания следующего последовательного фрагмента (классификация) из головы предсказания следующего фрагмента (оценки продолжения True/False до 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, ErnieForPreTraining >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh") >>> model = ErnieForPreTraining.from_pretrained("nghuyong/ernie-1.0-base-zh") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> prediction_logits = outputs.prediction_logits >>> seq_relationship_logits = outputs.seq_relationship_logits ``` ## ErnieForCausalLM[[transformers.ErnieForCausalLM]] #### transformers.ErnieForCausalLM[[transformers.ErnieForCausalLM]] ```python transformers.ErnieForCausalLM(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L849) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Ernie с головой `language modeling` для дообучения CLM. Эта модель наследуется от [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.ErnieForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, past_key_values: list[torch.Tensor] | None = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L874) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер. encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потери языкового моделирования слева направо (предсказание следующего слова). Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потеря вычисляется только для токенов с метками в диапазоне `[0, ..., config.vocab_size]` past_key_values (`list[torch.Tensor]`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входных данных допускается только экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по кэшу KV](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *необязательный*, по умолчанию `0`) : Если передано значение типа `int`, вычисляются logits для последних `logits_to_keep` токенов. Если передано `0`, logits вычисляются для всех `input_ids` (специальный случай). Для генерации нужны logits только последнего токена, и вычисление их только для этого токена позволяет сэкономить память, что становится весьма значимым для длинных последовательностей или большого размера словаря. Если передано значение типа `torch.Tensor`, оно должно быть одномерным и соответствовать индексам, которые нужно сохранить в измерении длины последовательности. Это полезно при использовании упакованного формата тензоров (одно измерение для batch и длины последовательности). **Возвращает:** [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) или `tuple(torch.Tensor)` Объект [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод [ErnieForCausalLM](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForCausalLM) forward переопределяет специальный метод `__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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **cross_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса кросс-внимания после softmax-функции внимания, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/v5.23.0/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания), которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. Пример: ```python ``` ## ErnieForMaskedLM[[transformers.ErnieForMaskedLM]] #### transformers.ErnieForMaskedLM[[transformers.ErnieForMaskedLM]] ```python transformers.ErnieForMaskedLM(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L940) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Ernie с головкой `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.ErnieForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L968) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер. encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. **Возвращает:** [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`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод forward класса [ErnieForMaskedLM](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForMaskedLM) переопределяет специальный метод `__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 >>> from transformers import AutoTokenizer, ErnieForMaskedLM >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> model = ErnieForMaskedLM.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> inputs = tokenizer("The capital of France is .", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> # retrieve index of >>> 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) >>> tokenizer.decode(predicted_token_id) ... >>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"] >>> # mask labels of non- tokens >>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100) >>> outputs = model(**inputs, labels=labels) >>> round(outputs.loss.item(), 2) ... ``` ## ErnieForNextSentencePrediction[[transformers.ErnieForNextSentencePrediction]] #### transformers.ErnieForNextSentencePrediction[[transformers.ErnieForNextSentencePrediction]] ```python transformers.ErnieForNextSentencePrediction(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1034) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Ernie с головкой `next sentence prediction (classification)`. Эта модель наследуется от [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.ErnieForNextSentencePrediction.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1044) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь предсказания следующей последовательности (классификации). Входом должна быть пара последовательностей (см. строку документации `input_ids`). Индексы должны находиться в диапазоне `[0, 1]`: - 0 означает, что последовательность B является продолжением последовательности A, - 1 означает, что последовательность B является случайной последовательностью. **Возвращает:** [NextSentencePredictorOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.NextSentencePredictorOutput) или `tuple(torch.Tensor)` Объект [NextSentencePredictorOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.NextSentencePredictorOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод forward класса [ErnieForNextSentencePrediction](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForNextSentencePrediction) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `next_sentence_label`) -- Потеря классификации для предсказания следующего предложения. - **logits** (`torch.Tensor` формы `(batch_size, 2)`) -- Оценки предсказания следующего элемента последовательности (классификация) из головы (classification) (оценки продолжения True/False до 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, ErnieForNextSentencePrediction >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh") >>> model = ErnieForNextSentencePrediction.from_pretrained("nghuyong/ernie-1.0-base-zh") >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced." >>> next_sentence = "The sky is blue due to the shorter wavelength of blue light." >>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt") >>> outputs = model(**encoding, labels=torch.LongTensor([1])) >>> logits = outputs.logits >>> assert logits[0, 0] < logits[0, 1] # next sentence was random ``` ## ErnieForSequenceClassification[[transformers.ErnieForSequenceClassification]] #### transformers.ErnieForSequenceClassification[[transformers.ErnieForSequenceClassification]] ```python transformers.ErnieForSequenceClassification(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1123) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель-трансформер Ernie с головой для классификации/регрессии последовательности (линейный слой поверх пул-вывода), например, для задач 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.ErnieForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1139) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия). **Возвращает:** [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`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод forward класса [ErnieForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForSequenceClassification) переопределяет специальный метод `__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, ErnieForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> model = ErnieForSequenceClassification.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> 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 = ErnieForSequenceClassification.from_pretrained("nghuyong/ernie-3.0-base-zh", 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, ErnieForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> model = ErnieForSequenceClassification.from_pretrained("nghuyong/ernie-3.0-base-zh", 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 = ErnieForSequenceClassification.from_pretrained( ... "nghuyong/ernie-3.0-base-zh", 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 ``` ## ErnieForMultipleChoice[[transformers.ErnieForMultipleChoice]] #### transformers.ErnieForMultipleChoice[[transformers.ErnieForMultipleChoice]] ```python transformers.ErnieForMultipleChoice(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1207) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Ernie с головой для классификации с множественным выбором (линейный слой поверх пул-вывода и softmax), например, для задач RocStories/SWAG. Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.ErnieForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1221) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательно*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательный*) : Task type embedding — это специальное вложение, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] position_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.max_position_embeddings - 1]`. [Что такое position IDs?](../glossary#position-ids) 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` выше) **Возвращает:** [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) или `tuple(torch.Tensor)` [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод [ErnieForMultipleChoice](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForMultipleChoice) forward переопределяет специальный метод `__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, ErnieForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> model = ErnieForMultipleChoice.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> 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 ``` ## ErnieForTokenClassification[[transformers.ErnieForTokenClassification]] #### transformers.ErnieForTokenClassification[[transformers.ErnieForTokenClassification]] ```python transformers.ErnieForTokenClassification(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1308) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Трансформер Ernie с головой для классификации токенов (линейный слой поверх выходных скрытых состояний), например, для задач распознавания именованных сущностей (NER). Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.ErnieForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1323) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления функции потерь классификации токенов. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. **Возвращает:** [TokenClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или `tuple(torch.Tensor)` Объект [TokenClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод forward класса [ErnieForTokenClassification](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForTokenClassification) переопределяет специальный метод `__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, ErnieForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> model = ErnieForTokenClassification.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> 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) ... ``` ## ErnieForQuestionAnswering[[transformers.ErnieForQuestionAnswering]] #### transformers.ErnieForQuestionAnswering[[transformers.ErnieForQuestionAnswering]] ```python transformers.ErnieForQuestionAnswering(config: ErnieConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1373) **Параметры:** config ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Трансформер Ernie со слоем классификации пропусков (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.ErnieForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, task_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/ernie/modeling_ernie.py#L1384) **Параметры:** input_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) task_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательный*) : Встраивание типа задачи — это специальное встраивание, представляющее характеристики различных задач, таких как предобучение с учётом слов, предобучение с учётом структуры и предобучение с учётом семантики. Каждой задаче назначается `task_type_id`, причём `task_type_id` находится в диапазоне `[0, config.task_type_vocab_size-1] 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. start_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) начала размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь. end_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) конца размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь. **Возвращает:** [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`), содержащий различные элементы в зависимости от конфигурации ([ErnieConfig](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieConfig)) и входных данных. Метод [ErnieForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/ernie#transformers.ErnieForQuestionAnswering) 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, ErnieForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> model = ErnieForQuestionAnswering.from_pretrained("nghuyong/ernie-3.0-base-zh") >>> 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) ... ```