# Longformer [Longformer](https://huggingface.co/papers/2004.05150) — это модель трансформера, предназначенная для обработки длинных документов. Операция само-внимания обычно масштабируется квадратично с длиной последовательности, что препятствует обработке трансформерами более длинных последовательностей. Механизм внимания Longformer преодолевает это ограничение, масштабируясь линейно с длиной последовательности. Он сочетает локальное оконное внимание с глобальным вниманием, специфичным для задачи, что позволяет эффективно обрабатывать документы, содержащие тысячи токенов. Все исходные контрольные точки Longformer можно найти в организации [Ai2](https://huggingface.co/allenai?search_models=longformer). > [!TIP] > Щёлкните по моделям Longformer в боковой панели справа, чтобы увидеть дополнительные примеры применения Longformer к различным языковым задачам. Пример ниже показывает, как заполнить токен `` с помощью [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="allenai/longformer-base-4096", device=0 ) pipeline("""San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the with a torn ligament in his left knee. Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit. Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.""") ``` ```python from transformers import AutoModelForMaskedLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") model = AutoModelForMaskedLM.from_pretrained("allenai/longformer-base-4096", device_map="auto") text = ( """ San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the with a torn ligament in his left knee. Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit. Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury. """ ) input_ids = tokenizer([text], return_tensors="pt").to(model.device)["input_ids"] logits = model(input_ids).logits masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() probs = logits[0, masked_index].softmax(dim=0) values, predictions = probs.topk(5) tokenizer.decode(predictions).split() ``` ## Примечания - Longformer основан на [RoBERTa](./roberta) и не имеет `token_type_ids`. Вам не нужно указывать, к какому сегменту относится токен. Достаточно разделять сегменты токеном разделения `` или `tokenizer.sep_token`. - Вы можете указать, какие токены обращаются локально, а какие — глобально, с помощью `global_attention_mask` на этапе инференса (см. этот [пример](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerModel.forward.example) для подробностей). Значение `0` означает, что токен обращается локально, а значение `1` — что токен обращается глобально. - [LongformerForMaskedLM](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerForMaskedLM) обучается так же, как [RobertaForMaskedLM](/docs/transformers/v5.23.0/ru/model_doc/roberta#transformers.RobertaForMaskedLM), и должен использоваться, как показано ниже. ```py input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt").to(model.device) mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device) loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0] ``` ## LongformerConfig[[transformers.LongformerConfig]] #### transformers.LongformerConfig[[transformers.LongformerConfig]] ```python transformers.LongformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, attention_window: list[int] | int = 512, sep_token_id: int | None = 2, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, 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, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, onnx_export: bool = False, tie_word_embeddings: bool = True) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/configuration_longformer.py#L24) **Параметры:** attention_window (`int` или `list[int]`, *необязательный*, по умолчанию 512) : Размер окна внимания вокруг каждого токена. Если указано значение типа `int`, этот размер будет использоваться для всех слоёв. Чтобы задать разный размер окна для каждого слоя, используйте `list[int]`, где `len(attention_window) == num_hidden_layers`. sep_token_id (`int`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемого в качестве разделителя в словаре. pad_token_id (`int`, *необязательный*, по умолчанию `1`) : Идентификатор токена, используемый для выравнивания в словаре. bos_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для обозначения начала потока в словаре. eos_token_id (`Union[int, list[int]]`, *необязательный*, по умолчанию `2`) : Идентификатор токена, используемого для обозначения конца потока в словаре. 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`. initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-12`) : Значение epsilon, используемое слоями нормализации. onnx_export (`bool`, *необязательный*, по умолчанию False) : Нужно ли создать модель так, чтобы её можно было экспортировать в ONNX. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. Это класс конфигурации для хранения настроек модели LongformerModel. Он используется для создания модели Longformer в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [allenai/longformer-base-4096](https://huggingface.co/allenai/longformer-base-4096) Объекты конфигурации наследуются от [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 LongformerConfig, LongformerModel >>> # Initializing a Longformer configuration >>> configuration = LongformerConfig() >>> # Initializing a model from the configuration >>> model = LongformerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LongformerTokenizer[[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/v5.23.0/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/v5.23.0/ru/main_classes/tokenizer#transformers.TokenizersBackend), который содержит большинство основных методов. За дополнительной информацией об этих методах следует обращаться к этому суперклассу. ## Специфические для Longformer выходные данные[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]] #### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput(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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L41) **Параметры:** 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов Longformer, с потенциальными скрытыми состояниями, локальным и глобальным вниманиями. #### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling]] ```python transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling(last_hidden_state: Tensor, pooler_output: typing.Optional[torch.Tensor] = None, 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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L79) **Параметры:** last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) : Последовательность скрытых состояний на выходе последнего слоя модели. pooler_output (`torch.Tensor` формы `(batch_size, hidden_size)`) : Скрытое состояние последнего слоя для первого токена последовательности (токен классификации), дополнительно обработанное линейным слоем и функцией активации 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, 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов Longformer, который также содержит пулинг последних скрытых состояний. #### transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput[[transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, 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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L122) **Параметры:** 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, 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей маскированного языка. #### transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput[[transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, 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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L165) **Параметры:** 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, 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей Longformer для задачи question answering. #### transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, 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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L207) **Параметры:** 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, 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей классификации предложений. #### transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput[[transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, 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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L250) **Параметры:** 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, 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей Longformer для задач множественного выбора. #### transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, 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/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L295) **Параметры:** 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, 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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Базовый класс для выходов моделей классификации токенов. ## LongformerModel[[transformers.LongformerModel]] #### transformers.LongformerModel[[transformers.LongformerModel]] ```python transformers.LongformerModel(config: LongformerConfig, add_pooling_layer = True) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1276) **Параметры:** config ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. add_pooling_layer (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли добавлять слой пулинга Модель Longformer без дополнительных слоёв, выводящая необработанные скрытые состояния. Эта модель наследуется от [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.LongformerModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.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) global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (внимание со скользящим окном), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое идентификаторы позиций?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LongformerBaseModelOutputWithPooling](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) или `tuple(torch.Tensor)` Объект [LongformerBaseModelOutputWithPooling](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) и входных данных. Метод forward модели [LongformerModel](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) — Скрытое состояние последнего слоя для первого токена последовательности (токен классификации), дополнительно обработанное линейным слоем и функцией активации 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, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности к каждому токену с глобальным вниманием (первые `x` значений) и к каждому токену в окне внимания (остальные `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Примеры: ```python >>> import torch >>> from transformers import LongformerModel, AutoTokenizer >>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096") >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000) # long input document >>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0) # batch of size 1 >>> attention_mask = torch.ones( ... input_ids.shape, dtype=torch.long, device=input_ids.device ... ) # initialize to local attention >>> global_attention_mask = torch.zeros( ... input_ids.shape, dtype=torch.long, device=input_ids.device ... ) # initialize to global attention to be deactivated for all tokens >>> global_attention_mask[ ... :, ... [ ... 1, ... 4, ... 21, ... ], ... ] = 1 # Set global attention to random tokens for the sake of this example >>> # Usually, set global attention based on the task. For example, >>> # classification: the token >>> # QA: question tokens >>> # LM: potentially on the beginning of sentences and paragraphs >>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask) >>> sequence_output = outputs.last_hidden_state >>> pooled_output = outputs.pooler_output ``` ## LongformerForMaskedLM[[transformers.LongformerForMaskedLM]] #### transformers.LongformerForMaskedLM[[transformers.LongformerForMaskedLM]] ```python transformers.LongformerForMaskedLM(config: LongformerConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1522) **Параметры:** config ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Longformer с головой `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.LongformerForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_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, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1543) **Параметры:** 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) global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (внимание со скользящим окном), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое идентификаторы позиций?](../glossary#position-ids) 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]`. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LongformerMaskedLMOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) или `tuple(torch.Tensor)` Объект [LongformerMaskedLMOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) и входных данных. Метод forward класса [LongformerForMaskedLM](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerForMaskedLM) переопределяет специальный метод `__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, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности к каждому токену с глобальным вниманием (первые `x` значений) и к каждому токену в окне внимания (остальные `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Пример заполнения маски: ```python >>> from transformers import AutoTokenizer, LongformerForMaskedLM >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096") ``` Попробуем очень длинный вход. ```python >>> TXT = ( ... "My friends are but they eat too many carbs." ... + " That's why I decide not to eat with them." * 300 ... ) >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"] >>> logits = model(input_ids).logits >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() >>> probs = logits[0, masked_index].softmax(dim=0) >>> values, predictions = probs.topk(5) >>> tokenizer.decode(predictions).split() ['healthy', 'skinny', 'thin', 'good', 'vegetarian'] ``` ## LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]] #### transformers.LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]] ```python transformers.LongformerForSequenceClassification(config: LongformerConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1639) **Параметры:** config ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Longformer — трансформер с головой для классификации/регрессии последовательностей (линейный слой поверх пуллинг-выхода), например, для задач 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.LongformerForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_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, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1651) **Параметры:** 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) global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (внимание со скользящим окном), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое идентификаторы позиций?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка), если `config.num_labels > 1` — функция потерь классификации (кросс-энтропия). output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LongformerSequenceClassifierOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) или `tuple(torch.Tensor)` Объект [LongformerSequenceClassifierOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) и входных данных. Метод forward класса [LongformerForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerForSequenceClassification) переопределяет специальный метод `__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, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности к каждому токену с глобальным вниманием (первые `x` значений) и к каждому токену в окне внимания (остальные `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Пример классификации с одной меткой: ```python >>> import torch >>> from transformers import AutoTokenizer, LongformerForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096") >>> 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 = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", 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, LongformerForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", 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 = LongformerForSequenceClassification.from_pretrained( ... "allenai/longformer-base-4096", 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 ``` ## LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]] #### transformers.LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]] ```python transformers.LongformerForMultipleChoice(config: LongformerConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1966) **Параметры:** config ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Longformer с головой для классификации с множественным выбором (линейный слой поверх пул-вывода и 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.LongformerForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1977) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`) : Индексы токенов входной последовательности в словаре. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) token_type_ids (`torch.LongTensor` формы `(batch_size, num_choices, sequence_length)`, *необязательно*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` формы `(batch_size, num_choices, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (скользящее окно внимания), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации с множественным выбором. Индексы должны находиться в диапазоне `[0, ..., num_choices-1]`, где `num_choices` — размер второго измерения входных тензоров. (См. `input_ids` выше) 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` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LongformerMultipleChoiceModelOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) или `tuple(torch.Tensor)` Объект [LongformerMultipleChoiceModelOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) и входных данных. Метод forward класса [LongformerForMultipleChoice](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerForMultipleChoice) переопределяет специальный метод `__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, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности к каждому токену с глобальным вниманием (первые `x` значений) и к каждому токену в окне внимания (остальные `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Пример: ```python >>> from transformers import AutoTokenizer, LongformerForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096") >>> 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 ``` ## LongformerForTokenClassification[[transformers.LongformerForTokenClassification]] #### transformers.LongformerForTokenClassification[[transformers.LongformerForTokenClassification]] ```python transformers.LongformerForTokenClassification(config: LongformerConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1887) **Параметры:** config ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Трансформер Longformer с головой для классификации токенов (линейный слой поверх выходных скрытых состояний), например, для задач распознавания именованных сущностей (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.LongformerForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_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, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1899) **Параметры:** 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) global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (внимание со скользящим окном), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое идентификаторы позиций?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления функции потерь классификации токенов. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LongformerTokenClassifierOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) или `tuple(torch.Tensor)` Объект [LongformerTokenClassifierOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) и входных данных. Метод forward класса [LongformerForTokenClassification](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerForTokenClassification) переопределяет специальный метод `__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, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности к каждому токену с глобальным вниманием (первые `x` значений) и к каждому токену в окне внимания (остальные `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Пример: ```python >>> from transformers import AutoTokenizer, LongformerForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096") >>> 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) ... ``` ## LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]] #### transformers.LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]] ```python transformers.LongformerForQuestionAnswering(config: LongformerConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1758) **Параметры:** config ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Трансформер Longformer с головой для классификации пропусков (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.LongformerForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_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, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/longformer/modeling_longformer.py#L1769) **Параметры:** 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) global_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для определения типа внимания к каждому токену: локальное или глобальное. Токены с глобальным вниманием обращаются ко всем остальным токенам, и все остальные токены обращаются к ним. Это важно для дообучения под конкретные задачи, так как делает модель более гибкой в представлении задачи. Например, для классификации токену следует назначить глобальное внимание. Для QA все токены вопроса также должны иметь глобальное внимание. Подробности см. в [статье о Longformer](https://huggingface.co/papers/2004.05150). Значения маски выбираются из `[0, 1]`: - 0 для локального внимания (внимание со скользящим окном), - 1 для глобального внимания (токены, которые обращаются ко всем остальным токенам, и все остальные токены обращаются к ним). token_type_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы сегментных токенов для указания первой и второй частей входных данных. Индексы выбираются из `[0, 1]`: - 0 соответствует токену *предложения A*, - 1 соответствует токену *предложения B*. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`. [Что такое идентификаторы позиций?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. start_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) начала размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь. end_positions (`torch.Tensor` формы `(batch_size,)`, *необязательный*) : Метки для позиции (индекса) конца размеченного фрагмента для вычисления функции потерь классификации токенов. Позиции ограничиваются длиной последовательности (`sequence_length`). Позиции вне последовательности не учитываются при вычислении функции потерь. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [LongformerQuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) или `tuple(torch.Tensor)` Объект [LongformerQuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([LongformerConfig](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerConfig)) и входных данных. Метод forward класса [LongformerForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/longformer#transformers.LongformerForQuestionAnswering) переопределяет специальный метод `__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, x + attention_window + 1)`, где `x` — количество токенов с глобальной маской внимания. Локальные веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена в последовательности к каждому токену с глобальным вниманием (первые `x` значений) и к каждому токену в окне внимания (остальные `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Это веса внимания от каждого токена с глобальным вниманием к каждому токену в последовательности. Примеры: ```python >>> from transformers import AutoTokenizer, LongformerForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa") >>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa") >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" >>> encoding = tokenizer(question, text, return_tensors="pt") >>> input_ids = encoding["input_ids"] >>> # default is local attention everywhere >>> # the forward method will automatically set global attention on question tokens >>> attention_mask = encoding["attention_mask"] >>> outputs = model(input_ids, attention_mask=attention_mask) >>> start_logits = outputs.start_logits >>> end_logits = outputs.end_logits >>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist()) >>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1] >>> answer = tokenizer.decode( ... tokenizer.convert_tokens_to_ids(answer_tokens) ... ) # remove space prepending space token ```