# LED [Longformer-Encoder-Decoder (LED)](https://huggingface.co/papers/2004.05150) — это трансформерная модель с архитектурой «энкодер-декодер» для задач последовательность-в-последовательность, таких как суммаризация. Она расширяет [Longformer](longformer) — модель только с энкодером, предназначенную для обработки длинных входных данных, — за счёт добавления слоя декодера. Декодер использует полное само-внимание по закодированным токенам и ранее декодированным позициям. Благодаря линейному механизму само-внимания в Longformer, LED эффективнее стандартных моделей «энкодер-декодер» при обработке длинных последовательностей. Все исходные контрольные точки [LED] можно найти в организации [Ai2](https://huggingface.co/allenai/models?search=led). > [!TIP] > Эта модель была предоставлена пользователем [patrickvonplaten](https://huggingface.co/patrickvonplaten). > > Нажмите на модели LED в боковой панели справа, чтобы увидеть дополнительные примеры применения LED к различным языковым задачам. Приведённый ниже пример показывает, как суммаризовать текст с помощью [Pipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel) и из командной строки. ```python import torch from transformers import AutoModelForSeq2SeqLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained( "allenai/led-base-16384" ) model = AutoModelForSeq2SeqLM.from_pretrained( "allenai/led-base-16384", device_map="auto" ) input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet. Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems. These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure. This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle.""" input_ids = tokenizer(input_text, return_tensors="pt").to(model.device) # Place global attention on the first token global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device) global_attention_mask[:, 0] = 1 output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static") print(tokenizer.decode(output[0], skip_special_tokens=True)) ``` Квантование снижает нагрузку на память при работе с большими моделями, представляя веса в пониженной точности. Подробнее о доступных бэкендах квантования см. в обзоре [Квантование](../quantization/overview). Приведённый ниже пример использует [bitsandbytes](../quantization/bitsandbytes) для квантования только весов до int4. ```python import torch from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig quantization_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4" ) model = AutoModelForSeq2SeqLM.from_pretrained( "allenai/led-large-16384", device_map="auto", quantization_config=quantization_config ) tokenizer = AutoTokenizer.from_pretrained( "allenai/led-large-16384" ) input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet. Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems. These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure. This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle.""" input_ids = tokenizer(input_text, return_tensors="pt").to(model.device) # Place global attention on the first token global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device) global_attention_mask[:, 0] = 1 output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static") print(tokenizer.decode(output[0], skip_special_tokens=True)) ``` ## Примечания - [LEDForConditionalGeneration](/docs/transformers/main/ru/model_doc/led#transformers.LEDForConditionalGeneration) — это расширение [BartForConditionalGeneration](/docs/transformers/main/ru/model_doc/bart#transformers.BartForConditionalGeneration), в котором традиционный слой self-attention заменён на слой chunked self-attention из Longformer. [LEDTokenizer](/docs/transformers/main/ru/model_doc/led#transformers.RobertaTokenizer) является псевдонимом [BartTokenizer](/docs/transformers/main/ru/model_doc/led#transformers.RobertaTokenizer). - LED дополняет `input_ids` до кратного `config.attention_window`, если это необходимо. Небольшое ускорение достигается при использовании [LEDTokenizer](/docs/transformers/main/ru/model_doc/led#transformers.RobertaTokenizer) с аргументом `pad_to_multiple_of`. - LED лучше всего работает на задачах последовательность-в-последовательность с длинными последовательностями, где `input_ids` значительно длиннее 1024 токенов. - LED использует глобальное внимание с помощью `global_attention_mask` (см. [LongformerModel](/docs/transformers/main/ru/model_doc/longformer#transformers.LongformerModel)). Для задачи суммаризации рекомендуется применять глобальное внимание только к первому токену ``. Для задачи ответа на вопросы рекомендуется применять глобальное внимание ко всем токенам вопроса. - Чтобы дообучить LED по всем 16384 параметрам, можно включить gradient checkpointing, если в процессе обучения возникают ошибки out-of-memory (OOM). Для включения gradient checkpointing добавьте `model.gradient_checkpointing_enable()` и установите `use_cache=False`, чтобы отключить механизм кэширования и сэкономить память. - Входные данные следует дополнять нулями справа, так как LED использует абсолютные позиционные эмбеддинги. ## Ресурсы - Ознакомьтесь с [ноутбуком LED на Arxiv](https://colab.research.google.com/drive/12INTTR6n64TzS4RrXZxMSXfrOd9Xzamo?usp=sharing), чтобы увидеть, как LED достигает передовых результатов в задаче суммаризации статей Arxiv. - Ознакомьтесь с [блокнотом Fine-tune LED](https://colab.research.google.com/drive/12LjJazBl7Gam0XBPy_y0CTOJZeZ34c2v?usp=sharing), чтобы узнать, как дообучить LED на статьях из PubMed. ## LEDConfig[[transformers.LEDConfig]] #### transformers.LEDConfig[[transformers.LEDConfig]] ```python transformers.LEDConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 50265, max_encoder_position_embeddings: int = 16384, max_decoder_position_embeddings: int = 1024, encoder_layers: int = 12, encoder_ffn_dim: int = 4096, encoder_attention_heads: int = 16, decoder_layers: int = 12, decoder_ffn_dim: int = 4096, decoder_attention_heads: int = 16, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'gelu', d_model: int = 1024, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, decoder_start_token_id: int = 2, classifier_dropout: float | int = 0.0, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, attention_window: list[int] | int = 512, tie_word_embeddings: bool = True) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/configuration_led.py#L24) **Параметры:** is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера. vocab_size (`int`, *необязательный*, по умолчанию `50265`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`. max_encoder_position_embeddings (`int`, *optional*, по умолчанию 16384) : Максимальная длина последовательности, с которой может использоваться кодировщик. max_decoder_position_embeddings (`int`, *optional*, по умолчанию 16384) : Максимальная длина последовательности, с которой может использоваться декодер. encoder_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в кодере Transformer. Если не задано, будет использовано то же значение, что и у `num_layers`. encoder_ffn_dim (`int`, *optional*, по умолчанию `4096`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в энкодере. encoder_attention_heads (`int`, *необязательный*, по умолчанию `16`) : Количество головок внимания для каждого слоя внимания в кодере Transformer. decoder_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer. Если не задано, будет использовано то же значение, что и у `num_layers`. decoder_ffn_dim (`int`, *необязательный*, по умолчанию `4096`) : Размерность «промежуточного» (часто называемого feed-forward) слоя в декодере. decoder_attention_heads (`int`, *необязательный*, по умолчанию `16`) : Количество головок внимания для каждого слоя внимания в декодере Transformer. encoder_layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop для энкодера. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556). decoder_layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность LayerDrop для декодера. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556). use_cache (`bool`, *необязательный*, по умолчанию `True`) : Следует ли модели возвращать последние значения внимания key/values (не используется во всех моделях). Актуально только при `config.is_decoder=True` или если модель является генеративной моделью только с декодером. activation_function (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. d_model (`int`, *необязательный*, по умолчанию `1024`) : Размер слоев кодировщика и пулера. dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout. attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания. activation_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для активаций внутри полносвязного слоя. init_std (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. decoder_start_token_id (`int`, *optional*, по умолчанию `2`) : Если модель с кодировщиком-декодировщиком начинает декодирование с токена, отличного от `bos`, идентификатор этого токена. classifier_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для классификатора. pad_token_id (`int`, *необязательный*, по умолчанию `1`) : Идентификатор токена, используемый для выравнивания в словаре. bos_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для обозначения начала потока в словаре. eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемого для обозначения конца потока в словаре. attention_window (`int` или `list[int]`, *необязательный*, по умолчанию 512) : Размер окна внимания вокруг каждого токена. Если указано значение типа `int`, этот размер будет использоваться для всех слоёв. Чтобы задать разный размер окна для каждого слоя, используйте `list[int]`, где `len(attention_window) == num_hidden_layers`. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. Это класс конфигурации для хранения настроек модели LEDModel. Он используется для создания модели Led в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [allenai/led-base-16384](https://huggingface.co/allenai/led-base-16384) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```python >>> from transformers import LEDModel, LEDConfig >>> # Initializing a LED allenai/led-base-16384 style configuration >>> configuration = LEDConfig() >>> # Initializing a model from the allenai/led-base-16384 style configuration >>> model = LEDModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LEDTokenizer[[transformers.RobertaTokenizer]] #### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]] ```python transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', bos_token: str = '', eos_token: str = '', sep_token: str = '', cls_token: str = '', unk_token: str = '', pad_token: str = '', mask_token: str = '', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/roberta/tokenization_roberta.py#L28) **Параметры:** vocab (`str`, `dict` или `list`, *необязательный*) : Пользовательский словарь. Если не указан, словарь загружается из vocab_file. merges (`str` или `list`, *необязательный*) : Пользовательский список слияний. Если не указан, слияния загружаются из merges_file. errors (`str`, *необязательный*, по умолчанию `"replace"`) : Парадигма, которой следует при декодировании байтов в UTF-8. Подробнее см. [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode). bos_token (`str`, *optional*, по умолчанию `""`) : Токен начала последовательности, использовавшийся во время предварительного обучения. Может использоваться в качестве токена классификатора последовательности. При построении последовательности с использованием специальных токенов этот токен не используется для обозначения начала последовательности. Для этой цели применяется токен `cls_token`. eos_token (`str`, *необязательный*, по умолчанию `""`) : Токен конца последовательности. При построении последовательности с использованием специальных токенов этот токен не используется для обозначения конца последовательности. Вместо него применяется токен `sep_token`. sep_token (`str`, *необязательный*, по умолчанию `""`) : Токен-разделитель, который используется при построении последовательности из нескольких последовательностей, например, двух последовательностей для классификации последовательностей или текста и вопроса для ответа на вопросы. Он также используется в качестве последнего токена последовательности, построенной с помощью специальных токенов. cls_token (`str`, *необязательный*, по умолчанию `""`) : Токен классификатора, используемый при классификации последовательности (классификация всей последовательности, а не посимвольная классификация). Это первый токен последовательности, если она построена с использованием специальных токенов. unk_token (`str`, *необязательный*, по умолчанию `""`) : Неизвестный токен. Токен, отсутствующий в словаре, не может быть преобразован в ID, вместо этого ему присваивается данный токен. pad_token (`str`, *необязательный*, по умолчанию `""`) : токен, используемый для выравнивания, например, при пакетной обработке последовательностей разной длины. mask_token (`str`, *необязательный*, по умолчанию `""`) : Токен, используемый для маскирования значений. Это тот токен, который применяется при обучении модели с использованием маскированного языкового моделирования. Именно этот токен модель будет пытаться предсказать. add_prefix_space (`bool`, *необязательный*, по умолчанию `False`) : Добавлять ли начальный пробел к входным данным. Это позволяет обрабатывать первое слово так же, как и любое другое. (Токенизатор RoBERTa определяет начало слов по предшествующему пробелу). trim_offsets (`bool`, *необязательный*, по умолчанию `True`) : Следует ли на этапе постобработки обрезать смещения, чтобы избежать включения пробельных символов. Создайте токенизатор RoBERTa (на базе библиотеки tokenizers от HuggingFace). Основан на байт-парной кодировке (Byte-Pair-Encoding). Этот токенизатор обучен обрабатывать пробелы как часть токенов (немного в духе sentencepiece), поэтому слово будет кодируются по-разному в зависимости от того, находятся ли они в начале предложения (без пробела) или нет: ```python >>> from transformers import RobertaTokenizer >>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base") >>> tokenizer("Hello world")["input_ids"] [0, 31414, 232, 2] >>> tokenizer(" Hello world")["input_ids"] [0, 20920, 232, 2] ``` Этому поведению можно избежать, передав `add_prefix_space=True` при создании экземпляра этого токенизатора или при его вызове на каком-либо тексте, однако, поскольку модель не была предобучена таким образом, это может привести к снижению производительности. При использовании с `is_split_into_words=True` этот токенизатор необходимо инициализировать с `add_prefix_space=True`. Этот токенизатор наследуется от [TokenizersBackend](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend), который содержит большинство основных методов. За дополнительной информацией об этих методах следует обращаться к этому суперклассу. #### get_special_tokens_mask[[transformers.RobertaTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L1337) **Параметры:** token_ids_0 : список идентификаторов для (возможно, уже отформатированной) последовательности. token_ids_1 : Не используется, если `already_has_special_tokens=True`. В этом случае должно быть None. already_has_special_tokens : Указывает, уже ли последовательность отформатирована со специальными токенами. **Возвращаемое значение:** список целых чисел в диапазоне [0, 1] 1 для специального токена, 0 для токена последовательности. Получить идентификаторы последовательностей из списка токенов, в который не добавлены специальные токены. Для быстрых токенизаторов коллабораторы данных вызывают этот метод с `already_has_special_tokens=True`, чтобы построить маску для уже отформатированной последовательности. В этом случае маска вычисляется путём проверки принадлежности элементов `all_special_ids`. #### save_vocabulary[[transformers.RobertaTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L547) ## LED-специфичные выходные[[transformers.models.led.modeling_led.LEDEncoderBaseModelOutput]] #### transformers.models.led.modeling_led.LEDEncoderBaseModelOutput[[transformers.models.led.modeling_led.LEDEncoderBaseModelOutput]] ```python transformers.models.led.modeling_led.LEDEncoderBaseModelOutput(last_hidden_state: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1063) **Параметры:** last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) : Последовательность скрытых состояний на выходе последнего слоя модели. hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные данные начальных встраиваний. attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности ко всем токенам с глобальным вниманием (первые `x` значений) и ко всем токенам в окне внимания (остальные `attention_window + 1` значений). Обратите внимание, что первые `x` значений относятся к токенам с фиксированными позициями в тексте, а остальные `attention_window + 1` значений относятся к токенам с относительными позициями: вес внимания токена к самому себе находится по индексу `x + attention_window / 2`, а `attention_window / 2` предшествующих (последующих) значений — это веса внимания к `attention_window / 2` предшествующим (последующим) токенам. Если в окне внимания содержится токен с глобальным вниманием, вес внимания по соответствующему индексу устанавливается в 0; значение следует извлекать из первых `x` весов внимания. Если токен имеет глобальное внимание, веса внимания ко всем остальным токенам в `attentions` устанавливаются в 0, значения следует извлекать из `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов LEDEncoder, с потенциальными скрытыми состояниями, локальным и глобальным вниманиями. #### transformers.models.led.modeling_led.LEDSeq2SeqModelOutput[[transformers.models.led.modeling_led.LEDSeq2SeqModelOutput]] ```python transformers.models.led.modeling_led.LEDSeq2SeqModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1102) **Параметры:** last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) : Последовательность скрытых состояний на выходе последнего слоя декодера модели. Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`. past_key_values (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) : это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшу kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. decoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также начальные выводы встраиваний. decoder_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 внимания, используемые для вычисления взвешенного среднего в головах кросс-внимания. encoder_last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика модели. encoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния энкодера на выходе каждого слоя, а также начальные выводы встраиваний. encoder_attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кодировщика после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. encoder_global_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов кодировщика модели, который также содержит: предварительно вычисленные скрытые состояния, способные ускорить последовательное декодирование. #### transformers.models.led.modeling_led.LEDSeq2SeqLMOutput[[transformers.models.led.modeling_led.LEDSeq2SeqLMOutput]] ```python transformers.models.led.modeling_led.LEDSeq2SeqLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1140) **Параметры:** loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если предоставлен `labels`) : Потеря языковой модели. logits (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) : Оценки предсказаний языковой модели (оценки для каждого токена словаря до SoftMax). past_key_values (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) : это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшу kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. decoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также начальные выводы встраиваний. decoder_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 внимания, используемые для вычисления взвешенного среднего в головах кросс-внимания. encoder_last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика модели. encoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния энкодера на выходе каждого слоя, а также начальные выводы встраиваний. encoder_attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кодировщика после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. encoder_global_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов языковых моделей последовательность-в-последовательность. #### transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput[[transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput]] ```python transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1178) **Параметры:** loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если указан `label`) : Потери классификации (или регрессии, если config.num_labels==1). logits (`torch.Tensor` формы `(batch_size, config.num_labels)`) : Оценки классификации (или регрессии, если config.num_labels==1) (до SoftMax). past_key_values (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) : это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшу kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. decoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также начальные выводы встраиваний. decoder_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 внимания, используемые для вычисления взвешенного среднего в головах кросс-внимания. encoder_last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика модели. encoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния энкодера на выходе каждого слоя, а также начальные выводы встраиваний. encoder_attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кодировщика после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. encoder_global_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей классификации предложений с последовательности в последовательность. #### transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput[[transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput]] ```python transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, encoder_global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1216) **Параметры:** loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) : Суммарная потеря извлечения пропусков представляет собой сумму кросс-энтропии для начальной и конечной позиций. start_logits (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Оценки начала пролёта (до SoftMax). end_logits (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательно*) : Оценки конца пропусков (до SoftMax). past_key_values (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) : это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшу kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. decoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также начальные выводы встраиваний. decoder_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 внимания, используемые для вычисления взвешенного среднего в головах кросс-внимания. encoder_last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика модели. encoder_hidden_states (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния энкодера на выходе каждого слоя, а также начальные выводы встраиваний. encoder_attentions (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания кодировщика после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. encoder_global_attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей вопросно-ответного типа с последовательности в последовательность. ## LEDModel[[transformers.LEDModel]] #### transformers.LEDModel[[transformers.LEDModel]] ```python transformers.LEDModel(config: LEDConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1723) **Параметры:** config ([LEDConfig](/docs/transformers/main/ru/model_doc/led#transformers.LEDConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Базовая модель Led, выводящая необработанные скрытые состояния без какого-либо специализированного слоя наверху. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.LEDModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1749) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательно*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью `LedTokenizer`. Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) LED использует `eos_token_id` в качестве начального токена для генерации `decoder_input_ids`. Если используется `past_key_values`, необязательно вводить только последние `decoder_input_ids` (см. `past_key_values`). decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Поведение по умолчанию: генерирует тензор, игнорирующий токены заполнения в `decoder_input_ids`. Маска причинности также будет использоваться по умолчанию. Если вы хотите изменить поведение при заполнении, прочитайте `modeling_led._prepare_decoder_inputs` и измените его в соответствии со своими потребностями. Дополнительную информацию о стратегии по умолчанию см. на схеме 1 в [статье](https://huggingface.co/papers/1910.13461). encoder_outputs (`tuple[tuple[torch.Tensor]]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное внимание для энкодера. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (скользящее окно внимания), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход нужно передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это делает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LEDSeq2SeqModelOutput](/docs/transformers/main/ru/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqModelOutput) или `tuple(torch.Tensor)` Объект [LEDSeq2SeqModelOutput](/docs/transformers/main/ru/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqModelOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LEDConfig](/docs/transformers/main/ru/model_doc/led#transformers.LEDConfig)) и входных данных. Метод forward класса [LEDModel](/docs/transformers/main/ru/model_doc/led#transformers.LEDModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя декодера модели. Если используется `past_key_values`, выводится только последнее скрытое состояние последовательностей формы `(batch_size, 1, hidden_size)`. - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания. - **decoder_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 к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний. - **encoder_attentions** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **encoder_global_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. ## LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]] #### transformers.LEDForConditionalGeneration[[transformers.LEDForConditionalGeneration]] ```python transformers.LEDForConditionalGeneration(config: LEDConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1865) **Параметры:** config ([LEDConfig](/docs/transformers/main/ru/model_doc/led#transformers.LEDConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель LED с головой для моделирования языка. Может использоваться для суммаризации. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.LEDForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L1897) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательно*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью `LedTokenizer`. Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) LED использует `eos_token_id` в качестве начального токена для генерации `decoder_input_ids`. Если используется `past_key_values`, необязательно вводить только последние `decoder_input_ids` (см. `past_key_values`). decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Поведение по умолчанию: генерирует тензор, игнорирующий токены заполнения в `decoder_input_ids`. Маска причинности также будет использоваться по умолчанию. Если вы хотите изменить поведение при заполнении, прочитайте `modeling_led._prepare_decoder_inputs` и измените его в соответствии со своими потребностями. Дополнительную информацию о стратегии по умолчанию см. на схеме 1 в [статье](https://huggingface.co/papers/1910.13461). encoder_outputs (`tuple[tuple[torch.Tensor]]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное внимание для энкодера. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (скользящее окно внимания), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). past_key_values (`~cache_utils.Cache`, *необязательный*) : Предварительно вычисленные скрытые состояния (ключи и значения в блоках само-внимания и кросс-внимания), которые можно использовать для ускорения последовательного декодирования. Обычно это `past_key_values`, возвращаемые моделью на предыдущем этапе декодирования, когда `use_cache=True` или `config.use_cache=True`. В качестве входного значения допускается только экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache), см. наше [руководство по kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Если `past_key_values` не переданы, по умолчанию будет инициализирован [DynamicCache](/docs/transformers/main/ru/internal/generation_utils#transformers.DynamicCache). Модель будет выводить тот же формат кэша, который был передан на вход. Если используются `past_key_values`, ожидается, что пользователь передаст только необработанные `input_ids` (те, для которых не заданы их прошлые состояния ключей и значений в этой модели) с формой `(batch_size, unprocessed_length)` вместо всех `input_ids` с формой `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход нужно передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это делает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LEDSeq2SeqLMOutput](/docs/transformers/main/ru/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqLMOutput) или `tuple(torch.Tensor)` Объект [LEDSeq2SeqLMOutput](/docs/transformers/main/ru/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqLMOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LEDConfig](/docs/transformers/main/ru/model_doc/led#transformers.LEDConfig)) и входных данных. Метод forward класса [LEDForConditionalGeneration](/docs/transformers/main/ru/model_doc/led#transformers.LEDForConditionalGeneration) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потеря языковой модели. - **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax). - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания. - **decoder_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 к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний. - **encoder_attentions** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **encoder_global_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Пример суммаризации: ```python >>> import torch >>> from transformers import AutoTokenizer, LEDForConditionalGeneration >>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv") >>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv") >>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art ... results in a wide range of natural language tasks including generative language modeling ... (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019). ... This success is partly due to the self-attention component which enables the network to capture contextual ... information from the entire sequence. While powerful, the memory and computational requirements of ... self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to ... process long sequences. To address this limitation, we present Longformer, a modified Transformer ... architecture with a self-attention operation that scales linearly with the sequence length, making it ... versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as ... long document classification, question answering (QA), and coreference resolution, where existing approaches ... partition or shorten the long context into smaller sequences that fall within the typical 512 token limit ... of BERT-style pretrained models. Such partitioning could potentially result in loss of important ... cross-partition information, and to mitigate this problem, existing methods often rely on complex ... architectures to address such interactions. On the other hand, our proposed Longformer is able to build ... contextual representations of the entire context using multiple layers of attention, reducing the need for ... task-specific architectures.''' >>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt") >>> # Global attention on the first token (cf. Beltagy et al. 2020) >>> global_attention_mask = torch.zeros_like(inputs) >>> global_attention_mask[:, 0] = 1 >>> # Generate Summary >>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32) >>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)) ``` Пример условной генерации: ```python >>> from transformers import AutoTokenizer, LEDForConditionalGeneration >>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384") >>> TXT = "My friends are but they eat too many carbs." >>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384") >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"] >>> prediction = model.generate(input_ids)[0] >>> print(tokenizer.decode(prediction, skip_special_tokens=True)) ``` ## LEDForQuestionAnswering[[transformers.LEDForQuestionAnswering]] #### transformers.LEDForQuestionAnswering[[transformers.LEDForQuestionAnswering]] ```python transformers.LEDForQuestionAnswering(config: LEDConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L2051) **Параметры:** config ([LEDConfig](/docs/transformers/main/ru/model_doc/led#transformers.LEDConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Led-трансформер с головой для классификации пролётов (span classification) для задач извлекающего вопросно-ответного типа, таких как SQuAD (линейный слой поверх выходных скрытых состояний для вычисления `span start logits` и `span end logits`). Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.LEDForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, global_attention_mask: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/led/modeling_led.py#L2064) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/main/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательно*) : Индексы токенов входной последовательности декодера в словаре. Индексы можно получить с помощью `LedTokenizer`. Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/main/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) LED использует `eos_token_id` в качестве начального токена для генерации `decoder_input_ids`. Если используется `past_key_values`, необязательно вводить только последние `decoder_input_ids` (см. `past_key_values`). decoder_attention_mask (`torch.LongTensor` формы `(batch_size, target_sequence_length)`, *необязательный*) : Поведение по умолчанию: генерирует тензор, игнорирующий токены заполнения в `decoder_input_ids`. Маска причинности также будет использоваться по умолчанию. Если вы хотите изменить поведение при заполнении, прочитайте `modeling_led._prepare_decoder_inputs` и измените его в соответствии со своими потребностями. Дополнительную информацию о стратегии по умолчанию см. на схеме 1 в [статье](https://huggingface.co/papers/1910.13461). encoder_outputs (`tuple[tuple[torch.Tensor]]`, *необязательный*) : Кортеж состоит из (`last_hidden_state`, *необязательный*: `hidden_states`, *необязательный*: `attentions`) `last_hidden_state` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) представляет собой последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании декодера. global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное внимание для энкодера. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (скользящее окно внимания), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). start_positions (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) начала размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь. end_positions (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) конца размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь. inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. decoder_inputs_embeds (`torch.Tensor` формы `(batch_size, target_sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `decoder_input_ids` можно напрямую передать встроенное представление. Если используется `past_key_values`, по желанию на вход нужно передавать только последние `decoder_inputs_embeds` (см. `past_key_values`). Это полезно, если требуется больший контроль над тем, как индексы `decoder_input_ids` преобразуются в соответствующие векторы, чем это делает внутренняя матрица поиска встраиваний модели. Если `decoder_input_ids` и `decoder_inputs_embeds` не заданы, `decoder_inputs_embeds` принимает значение `inputs_embeds`. use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`). output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/ru/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput) или `tuple(torch.Tensor)` [LEDSeq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/ru/model_doc/led#transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LEDConfig](/docs/transformers/main/ru/model_doc/led#transformers.LEDConfig)) и входных данных. Метод forward класса [LEDForQuestionAnswering](/docs/transformers/main/ru/model_doc/led#transformers.LEDForQuestionAnswering) переопределяет специальный метод `__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). - **past_key_values** (`Cache`, *необязательный*, возвращается при передаче `use_cache=True` или когда `config.use_cache=True`) -- это экземпляр [Cache](/docs/transformers/main/ru/internal/generation_utils#transformers.Cache). Подробнее см. в нашем [руководстве по кэшированию kv](https://huggingface.co/docs/transformers/en/kv_cache). Содержит предварительно вычисленные скрытые состояния (ключи и значения в блоках внимания) декодера, которые можно использовать (см. вход `past_key_values`) для ускорения последовательного декодирования. - **decoder_hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния декодера на выходе каждого слоя, а также выходные значения начального слоя встраивания. - **decoder_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 к вниманию, используемые для вычисления взвешенного среднего в головах кросс-внимания. - **encoder_last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) -- Последовательность скрытых состояний на выходе последнего слоя энкодера модели. - **encoder_hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния кодировщика на выходе каждого слоя, а также выходные значения начального слоя встраиваний. - **encoder_attentions** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания энкодера после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. - **encoder_global_attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, x)`, где `x` — количество токенов с глобальной маской внимания. Глобальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Пример: ```python >>> from transformers import AutoTokenizer, LEDForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384") >>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384") >>> 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) ... ```