原文：huggingface.co/docs/transformers

M2M100

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/m2m_100

概述

M2M100 模型是由 Angela Fan、Shruti Bhosale、Holger Schwenk、Zhiyi Ma、Ahmed El-Kishky、Siddharth Goyal、Mandeep Baines、Onur Celebi、Guillaume Wenzek、Vishrav Chaudhary、Naman Goyal、Tom Birch、Vitaliy Liptchinsky、Sergey Edunov、Edouard Grave、Michael Auli、Armand Joulin 在 Beyond English-Centric Multilingual Machine Translation 中提出的。

该论文的摘要如下：

翻译领域的现有工作展示了通过训练单个模型能够在任意语言对之间进行翻译的巨大多语言机器翻译的潜力。然而，许多工作都是以英语为中心的，只在已经从英语翻译或翻译到英语的数据上进行训练。虽然这得到了大量的训练数据支持，但并不反映全球的翻译需求。在这项工作中，我们创建了一个真正的多对多多语言翻译模型，可以直接在任意一对 100 种语言之间进行翻译。我们构建并开源了一个训练数据集，涵盖了数千种语言方向的有监督数据，通过大规模挖掘创建。然后，我们探索如何通过密集缩放和特定语言的稀疏参数的组合有效地增加模型容量，以创建高质量的模型。我们专注于非英语为中心的模型，在直接翻译非英语方向时获得了超过 10 个 BLEU 的增益，同时在 WMT 最佳单一系统的竞争中表现出色。我们开源我们的脚本，以便其他人可以重现数据、评估和最终的 M2M-100 模型。

该模型由 valhalla 贡献。

使用提示和示例

M2M100 是一个多语言编码器-解码器（seq-to-seq）模型，主要用于翻译任务。由于该模型是多语言的，它期望序列以特定格式提供：在源文本和目标文本中都使用特殊的语言 id 标记作为前缀。源文本格式为 [lang_code] X [eos]，其中 lang_code 是源文本的源语言 id，也是目标文本的目标语言 id，X 是源文本或目标文本。

M2M100Tokenizer 依赖于 sentencepiece，请确保在运行示例之前安装它。要安装 sentencepiece，请运行 pip install sentencepiece。

有监督训练

from transformers import M2M100Config, M2M100ForConditionalGeneration, M2M100Tokenizer

model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="en", tgt_lang="fr")

src_text = "Life is like a box of chocolates."
tgt_text = "La vie est comme une boîte de chocolat."

model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")

loss = model(**model_inputs).loss  # forward pass

生成

M2M100 使用 eos_token_id 作为生成时的 decoder_start_token_id，并强制将目标语言 id 作为第一个生成的标记。要强制将目标语言 id 作为第一个生成的标记，请将 forced_bos_token_id 参数传递给 generate 方法。以下示例展示了如何使用 facebook/m2m100_418M 检查点在印地语到法语和中文到英语之间进行翻译。

>>> from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer

>>> hi_text = "जीवन एक चॉकलेट बॉक्स की तरह है।"
>>> chinese_text = "生活就像一盒巧克力。"

>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")

>>> # translate Hindi to French
>>> tokenizer.src_lang = "hi"
>>> encoded_hi = tokenizer(hi_text, return_tensors="pt")
>>> generated_tokens = model.generate(**encoded_hi, forced_bos_token_id=tokenizer.get_lang_id("fr"))
>>> tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"La vie est comme une boîte de chocolat."

>>> # translate Chinese to English
>>> tokenizer.src_lang = "zh"
>>> encoded_zh = tokenizer(chinese_text, return_tensors="pt")
>>> generated_tokens = model.generate(**encoded_zh, forced_bos_token_id=tokenizer.get_lang_id("en"))
>>> tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
"Life is like a box of chocolate."

资源

• 翻译任务指南

• 总结任务指南

M2M100Config

class transformers.M2M100Config

<来源>

( vocab_size = 128112 max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.05 decoder_layerdrop = 0.05 use_cache = True is_encoder_decoder = True activation_function = 'relu' d_model = 1024 dropout = 0.1 attention_dropout = 0.1 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 scale_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

• vocab_size（int，可选，默认为 50265）— M2M100 模型的词汇量。定义了在调用 M2M100Model 时可以表示的不同标记数量。

• d_model（int，可选，默认为 1024）— 层和池化层的维度。

• encoder_layers（int，可选，默认为 12）— 编码器层数。

• decoder_layers（int，可选，默认为 12）— 解码器层数。

• encoder_attention_heads（int，可选，默认为 16）— Transformer 编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。

• decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。

• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。

• classifier_dropout (float, optional, defaults to 0.0) — 分类器的 dropout 比率。

• max_position_embeddings (int, optional, defaults to 1024) — 模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。

• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅LayerDrop 论文。

• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅LayerDrop 论文。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是用于存储 M2M100Model 配置的配置类。根据指定的参数实例化一个 M2M100 模型，定义模型架构。使用默认值实例化配置将产生类似于M2M100架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import M2M100Config, M2M100Model

>>> # Initializing a M2M100 facebook/m2m100_418M style configuration
>>> configuration = M2M100Config()

>>> # Initializing a model (with random weights) from the facebook/m2m100_418M style configuration
>>> model = M2M100Model(configuration)

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

M2M100Tokenizer

class transformers.M2M100Tokenizer

<来源>

( vocab_file spm_file src_lang = None tgt_lang = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' pad_token = '<pad>' unk_token = '<unk>' language_codes = 'm2m100' sp_model_kwargs: Optional = None num_madeup_words = 8 **kwargs )

参数

• vocab_file (str) — 词汇表文件的路径。

• spm_file (str) — 包含词汇表的SentencePiece文件的路径（通常具有.spm 扩展名）。

• src_lang (str, optional) — 表示源语言的字符串。

• tgt_lang (str, optional) — 表示目标语言的字符串。

• eos_token (str, optional, defaults to "</s>") — 序列结束标记。

• sep_token (str, optional, defaults to "</s>") — 分隔符标记，在构建多个序列的序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• unk_token (str, 可选, 默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, 可选, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• language_codes (str, 可选, 默认为 "m2m100") — 要使用的语言代码。应为 "m2m100" 或 "wmt21" 之一。

• sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。SentencePiece 的 Python 包装器可用于设置：

  • enable_sampling: 启用子词正则化。

  • nbest_size: 用于 unigram 的抽样参数。对于 BPE-Dropout 无效。

    • nbest_size = {0,1}: 不执行抽样。

    • nbest_size > 1: 从 nbest_size 结果中抽样。

    • nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向抽样算法从所有假设（格子）中抽样。

  • alpha: unigram 抽样的平滑参数，以及 BPE-dropout 的合并操作的丢失概率。

构建一个 M2M100 标记器。基于SentencePiece。

此标记器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

示例：

>>> from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer

>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M", src_lang="en", tgt_lang="ro")
>>> src_text = " UN Chief Says There Is No Military Solution in Syria"
>>> tgt_text = "Şeful ONU declară că nu există o soluţie militară în Siria"
>>> model_inputs = tokenizer(src_text, text_target=tgt_text, return_tensors="pt")
>>> outputs = model(**model_inputs)  # should work

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。一个 MBART 序列具有以下格式，其中 X 表示序列：

• input_ids（用于编码器） X [eos, src_lang_code]

• decoder_input_ids:（用于解码器） X [eos, tgt_lang_code]

BOS 从不使用。序列对不是预期的用例，但它们将在没有分隔符的情况下处理。

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

• already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经使用模型的特殊标记格式化。

返回

List[int]

一个整数列表，范围为 [0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。在使用标记器 prepare_for_model 方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 第一个标记化序列。

• token_ids_1 (List[int], 可选) — 第二个标记化序列。

返回

List[int]

标记类型 ID。

创建与传递的序列相对应的标记类型 ID。什么是标记类型 ID？

如果模型有一种特殊的构建方式，则应在子类中重写此方法。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

M2M100Model

class transformers.M2M100Model

<来源>

( config: M2M100Config )

参数

• config (M2M100Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 M2M100 模型输出原始隐藏状态，没有特定的头部。此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头部等）。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。

  索引可以使用 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示标记未被掩码，

  • 0 表示标记被掩码。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。

  索引可以使用 AutoTokenizer 获得。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是解码器输入 ID？

  M2M100 使用eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask (torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

• head_mask (torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• decoder_head_mask (torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选） — 用于使解码器中交叉注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选） — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用past_key_values，用户可以选择只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选） — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，可以选择只输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选） — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.Seq2SeqModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时），包括根据配置（M2M100Config）和输入的各种元素。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。

  如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层输出的一个 + 每层输出的一个）。

  解码器在每一层输出的隐藏状态以及可选的初始嵌入输出。

• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层输出的一个 + 每层输出的一个）。

  编码器在每一层输出的隐藏状态以及可选的初始嵌入输出。

• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

M2M100Model 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会处理运行前处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, M2M100Model
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/m2m100_418M")
>>> model = M2M100Model.from_pretrained("facebook/m2m100_418M")

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

>>> last_hidden_states = outputs.last_hidden_state

M2M100ForConditionalGeneration

class transformers.M2M100ForConditionalGeneration

< source >

( config: M2M100Config )

参数

• config（M2M100Config）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

具有语言建模头部的 M2M100 模型。可用于摘要。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头部等）。

此模型还是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下，如果提供了填充，将会被忽略。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 遮罩，避免在填充标记索引上执行注意力。遮罩值选定在 [0, 1] 中：

  • 1 表示未被遮蔽的标记，

  • 0 表示被遮蔽的标记。

  什么是注意力遮罩？

• decoder_input_ids（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 词汇表中解码器输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  M2M100 使用 eos_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

• decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.LongTensor，可选）— 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。默认还将使用因果遮罩。

• head_mask（形状为 (encoder_layers, encoder_attention_heads) 的 torch.Tensor，可选）— 用于使编码器中注意力模块的选定头部失效的遮罩。遮罩值选定在 [0, 1] 中：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• decoder_head_mask（形状为 (decoder_layers, decoder_attention_heads) 的 torch.Tensor，可选）— 用于使解码器中注意力模块的选定头部失效的遮罩。遮罩值选定在 [0, 1] 中：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• cross_attn_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于将解码器中交叉注意力模块的选定头部置零的掩码。掩码值选定在 [0, 1] 之间：

  • 1 表示头部是 未被掩码，

  • 0 表示头部是 被掩码。

• encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — 元组包括 (last_hidden_state，可选: hidden_states，可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层的输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见 past_key_values 输入）。

  如果使用了 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（这些没有将它们的过去键值状态提供给此模型）的形状为 (batch_size, 1) 的张量，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用了 past_key_values，则可能只需输入最后的 decoder_inputs_embeds（请参见 past_key_values）。如果您想要更多控制如何将 decoder_input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

  如果 decoder_input_ids 和 decoder_inputs_embeds 都未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。

• use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（请参见 past_key_values）。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回的张量中的 attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回的张量中的 hidden_states。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

• labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（M2M100Config）和输入的各种元素。

• 损失 (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，在传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每层输出的一个）。

  解码器在每一层的输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(torch.FloatTensor)，可选，在传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor)，可选，在传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每层输出的一个）。

  编码器在每一层的输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(torch.FloatTensor)，可选，在传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

M2M100ForConditionalGeneration 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数中定义，但应该在之后调用Module实例，而不是这样，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。

翻译示例

>>> from transformers import AutoTokenizer, M2M100ForConditionalGeneration

>>> model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/m2m100_418M")

>>> text_to_translate = "Life is like a box of chocolates"
>>> model_inputs = tokenizer(text_to_translate, return_tensors="pt")

>>> # translate to French
>>> gen_tokens = model.generate(**model_inputs, forced_bos_token_id=tokenizer.get_lang_id("fr"))
>>> print(tokenizer.batch_decode(gen_tokens, skip_special_tokens=True))

MADLAD-400

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/madlad-400

概述

MADLAD-400 模型在论文 MADLAD-400: A Multilingual And Document-Level Large Audited Dataset 中发布。

论文摘要如下：

我们介绍了 MADLAD-400，这是一个基于 CommonCrawl 的手动审核的通用领域 3T 令牌单语数据集，涵盖了 419 种语言。我们讨论了自我审核 MADLAD-400 所揭示的限制，以及数据审核在数据集创建过程中的作用。然后，我们使用公开可用的数据训练并发布了一个覆盖 450 多种语言、共计 2500 亿令牌的 10.7B 参数多语言机器翻译模型，并发现它与规模更大的模型竞争力相当，并在不同领域报告了结果。此外，我们训练了一个 8B 参数的语言模型，并评估了少样本翻译的结果。我们将基线模型提供给研究社区。

此模型由Juarez Bochi添加。原始检查点可以在这里找到。

这是一个支持许多低资源语言的机器翻译模型，并且与规模更大的模型具有竞争力。

可以直接使用 MADLAD-400 权重而无需微调模型：

>>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

>>> model = AutoModelForSeq2SeqLM.from_pretrained("google/madlad400-3b-mt")
>>> tokenizer = AutoTokenizer.from_pretrained("google/madlad400-3b-mt")

>>> inputs = tokenizer("<2pt> I love pizza!", return_tensors="pt")
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Eu amo pizza!']

Google 发布了以下变体：

• google/madlad400-3b-mt

• google/madlad400-7b-mt

• google/madlad400-7b-mt-bt

• google/madlad400-10b-mt

原始检查点可以在这里找到。

有关所有 API 参考、代码示例和笔记本，请参考 T5 的文档页面。有关 MADLAD-400 的训练和评估的更多详细信息，请参考模型卡片。

MarianMT

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/marian

概述

一个用于翻译模型的框架，使用与 BART 相同的模型。翻译应该与每个模型卡链接的测试集中的输出类似，但不完全相同。此模型由sshleifer贡献。

实施说明

• 每个模型在磁盘上约为 298 MB，共有 1000 多个模型。

• 支持的语言对列表可以在这里找到。

• 模型最初由Jörg Tiedemann使用Marian C++库进行训练，该库支持快速训练和翻译。

• 所有模型都是具有 6 层的 transformer 编码器-解码器。每个模型的性能都记录在模型卡中。

• 不支持需要 BPE 预处理的 80 个 opus 模型。

• 建模代码与 BartForConditionalGeneration 相同，只有一些小修改：

  • 静态（正弦）位置嵌入（MarianConfig.static_position_embeddings=True）

  • 没有 layernorm_embedding（MarianConfig.normalize_embedding=False）

  • 模型从pad_token_id（其 token_embedding 为 0）作为前缀开始生成（Bart 使用<s/>），

• 可以在convert_marian_to_pytorch.py中找到批量转换模型的代码。

命名

• 所有模型名称都采用以下格式：Helsinki-NLP/opus-mt-{src}-{tgt}

• 用于命名模型的语言代码不一致。两位代码通常可以在这里找到，三位代码需要搜索“language code {code}”。

• 格式为es_AR的代码通常是code_{region}。那个是来自阿根廷的西班牙语。

• 这些模型分两个阶段转换。前 1000 个模型使用 ISO-639-2 代码标识语言，第二组使用 ISO-639-5 代码和 ISO-639-2 代码的组合。

示例

• 由于 Marian 模型比库中其他许多翻译模型更小，因此它们可以用于微调实验和集成测试。

• 在 GPU 上微调

多语言模型

• 所有模型名称都采用以下格式：Helsinki-NLP/opus-mt-{src}-{tgt}：

• 如果模型可以输出多种语言，则应通过在src_text前添加所需的输出语言来指定语言代码。

• 您可以在模型卡中查看模型支持的语言代码，如opus-mt-en-roa中的目标成分。

• 请注意，如果模型仅在源端是多语言的，例如Helsinki-NLP/opus-mt-roa-en，则不需要语言代码。

来自Tatoeba-Challenge 存储库的新多语言模型需要 3 个字符的语言代码：

>>> from transformers import MarianMTModel, MarianTokenizer

>>> src_text = [
...     ">>fra<< this is a sentence in english that we want to translate to french",
...     ">>por<< This should go to portuguese",
...     ">>esp<< And this to Spanish",
... ]

>>> model_name = "Helsinki-NLP/opus-mt-en-roa"
>>> tokenizer = MarianTokenizer.from_pretrained(model_name)
>>> print(tokenizer.supported_language_codes)
['>>zlm_Latn<<', '>>mfe<<', '>>hat<<', '>>pap<<', '>>ast<<', '>>cat<<', '>>ind<<', '>>glg<<', '>>wln<<', '>>spa<<', '>>fra<<', '>>ron<<', '>>por<<', '>>ita<<', '>>oci<<', '>>arg<<', '>>min<<']

>>> model = MarianMTModel.from_pretrained(model_name)
>>> translated = model.generate(**tokenizer(src_text, return_tensors="pt", padding=True))
>>> [tokenizer.decode(t, skip_special_tokens=True) for t in translated]
["c'est une phrase en anglais que nous voulons traduire en français",
 'Isto deve ir para o português.',
 'Y esto al español']

以下是查看 hub 上所有可用预训练模型的代码：

from huggingface_hub import list_models

model_list = list_models()
org = "Helsinki-NLP"
model_ids = [x.modelId for x in model_list if x.modelId.startswith(org)]
suffix = [x.split("/")[1] for x in model_ids]
old_style_multi_models = [f"{org}/{s}" for s in suffix if s != s.lower()]

旧风格多语言模型

这些是从 OPUS-MT-Train 存储库移植的旧风格多语言模型：以及每个语言组的成员：

['Helsinki-NLP/opus-mt-NORTH_EU-NORTH_EU',
 'Helsinki-NLP/opus-mt-ROMANCE-en',
 'Helsinki-NLP/opus-mt-SCANDINAVIA-SCANDINAVIA',
 'Helsinki-NLP/opus-mt-de-ZH',
 'Helsinki-NLP/opus-mt-en-CELTIC',
 'Helsinki-NLP/opus-mt-en-ROMANCE',
 'Helsinki-NLP/opus-mt-es-NORWAY',
 'Helsinki-NLP/opus-mt-fi-NORWAY',
 'Helsinki-NLP/opus-mt-fi-ZH',
 'Helsinki-NLP/opus-mt-fi_nb_no_nn_ru_sv_en-SAMI',
 'Helsinki-NLP/opus-mt-sv-NORWAY',
 'Helsinki-NLP/opus-mt-sv-ZH']
GROUP_MEMBERS = {
 'ZH': ['cmn', 'cn', 'yue', 'ze_zh', 'zh_cn', 'zh_CN', 'zh_HK', 'zh_tw', 'zh_TW', 'zh_yue', 'zhs', 'zht', 'zh'],
 'ROMANCE': ['fr', 'fr_BE', 'fr_CA', 'fr_FR', 'wa', 'frp', 'oc', 'ca', 'rm', 'lld', 'fur', 'lij', 'lmo', 'es', 'es_AR', 'es_CL', 'es_CO', 'es_CR', 'es_DO', 'es_EC', 'es_ES', 'es_GT', 'es_HN', 'es_MX', 'es_NI', 'es_PA', 'es_PE', 'es_PR', 'es_SV', 'es_UY', 'es_VE', 'pt', 'pt_br', 'pt_BR', 'pt_PT', 'gl', 'lad', 'an', 'mwl', 'it', 'it_IT', 'co', 'nap', 'scn', 'vec', 'sc', 'ro', 'la'],
 'NORTH_EU': ['de', 'nl', 'fy', 'af', 'da', 'fo', 'is', 'no', 'nb', 'nn', 'sv'],
 'SCANDINAVIA': ['da', 'fo', 'is', 'no', 'nb', 'nn', 'sv'],
 'SAMI': ['se', 'sma', 'smj', 'smn', 'sms'],
 'NORWAY': ['nb_NO', 'nb', 'nn_NO', 'nn', 'nog', 'no_nb', 'no'],
 'CELTIC': ['ga', 'cy', 'br', 'gd', 'kw', 'gv']
}

将英语翻译成多种罗曼语言的示例，使用旧风格的 2 字符语言代码

>>> from transformers import MarianMTModel, MarianTokenizer

>>> src_text = [
...     ">>fr<< this is a sentence in english that we want to translate to french",
...     ">>pt<< This should go to portuguese",
...     ">>es<< And this to Spanish",
... ]

>>> model_name = "Helsinki-NLP/opus-mt-en-ROMANCE"
>>> tokenizer = MarianTokenizer.from_pretrained(model_name)

>>> model = MarianMTModel.from_pretrained(model_name)
>>> translated = model.generate(**tokenizer(src_text, return_tensors="pt", padding=True))
>>> tgt_text = [tokenizer.decode(t, skip_special_tokens=True) for t in translated]
["c'est une phrase en anglais que nous voulons traduire en français", 
 'Isto deve ir para o português.',
 'Y esto al español']

资源

• 翻译任务指南

• 总结任务指南

• 因果语言建模任务指南

MarianConfig

class transformers.MarianConfig

<来源>

( vocab_size = 58101 decoder_vocab_size = None max_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 58100 scale_embedding = False pad_token_id = 58100 eos_token_id = 0 forced_eos_token_id = 0 share_encoder_decoder_embeddings = True **kwargs )

参数

• vocab_size (int, optional, defaults to 58101) — Marian 模型的词汇量。定义了在调用 MarianModel 或 TFMarianModel 时可以由inputs_ids表示的不同标记数量。

• d_model (int, optional, defaults to 1024) — 层和池化器层的维度。

• encoder_layers (int, optional, defaults to 12) — 编码器层数。

• decoder_layers (int, optional, defaults to 12) — 解码器层数。

• encoder_attention_heads (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。

• decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。

• decoder_ffn_dim (int, optional, defaults to 4096) — 解码器中“中间”（通常称为前馈）层的维度。

• encoder_ffn_dim (int, optional, defaults to 4096) — 编码器中“中间”（通常称为前馈）层的维度。

• activation_function (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。

• dropout (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

• activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。

• max_position_embeddings (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。

• init_std (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• encoder_layerdrop (float, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop paper)。

• scale_embedding (bool, optional, defaults to False) — 通过除以 sqrt(d_model)来缩放嵌入。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）

• forced_eos_token_id (int, optional, defaults to 0) — 当达到max_length时，强制作为最后生成的标记的标记 id。通常设置为eos_token_id。

这是用于存储 MarianModel 配置的配置类。根据指定的参数实例化一个 Marian 模型，定义模型架构。使用默认值实例化配置将产生类似于 MarianHelsinki-NLP/opus-mt-en-de架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import MarianModel, MarianConfig

>>> # Initializing a Marian Helsinki-NLP/opus-mt-en-de style configuration
>>> configuration = MarianConfig()

>>> # Initializing a model from the Helsinki-NLP/opus-mt-en-de style configuration
>>> model = MarianModel(configuration)

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

MarianTokenizer

class transformers.MarianTokenizer

< source >

( source_spm target_spm vocab target_vocab_file = None source_lang = None target_lang = None unk_token = '<unk>' eos_token = '</s>' pad_token = '<pad>' model_max_length = 512 sp_model_kwargs: Optional = None separate_vocabs = False **kwargs )

参数

• source_spm (str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含源语言的词汇。

• target_spm (str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含目标语言的词汇。

• source_lang (str, optional) — 表示源语言的字符串。

• target_lang (str, optional) — 表示目标语言的字符串。

• unk_token (str, optional, 默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• eos_token (str, optional, 默认为 "</s>") — 序列结束标记。

• pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• model_max_length (int, optional, 默认为 512) — 模型接受的最大句子长度。

• additional_special_tokens (List[str], optional, 默认为 ["<eop>", "<eod>"]) — 分词器使用的额外特殊标记。

• sp_model_kwargs (dict, optional) — 将传递给 SentencePieceProcessor.__init__() 方法。SentencePiece 的 Python 包装器 可以用于设置：

  • enable_sampling: 启用子词正则化。

  • nbest_size: 单字采样参数。对于 BPE-Dropout 无效。

    • nbest_size = {0,1}: 不执行抽样。

    • nbest_size > 1: 从 nbest_size 结果中抽样。

    • nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向抽样算法从所有假设（格子）中抽样。

  • alpha: 用于单字采样的平滑参数，以及用于 BPE-Dropout 合并操作的丢弃概率。

构建一个 Marian 分词器。基于 SentencePiece。

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

示例：

>>> from transformers import MarianForCausalLM, MarianTokenizer

>>> model = MarianForCausalLM.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> tokenizer = MarianTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> src_texts = ["I am a small frog.", "Tom asked his teacher for advice."]
>>> tgt_texts = ["Ich bin ein kleiner Frosch.", "Tom bat seinen Lehrer um Rat."]  # optional
>>> inputs = tokenizer(src_texts, text_target=tgt_texts, return_tensors="pt", padding=True)

>>> outputs = model(**inputs)  # should work

build_inputs_with_special_tokens

< source >

( token_ids_0 token_ids_1 = None )

通过附加 eos_token_id 从序列构建模型输入。

PytorchHide Pytorch content

MarianModel

class transformers.MarianModel

< source >

( config: MarianConfig )

参数

• config (MarianConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 Marian 模型输出原始隐藏状态，没有特定的头部。这个模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头部等）。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Union = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供填充标记，则将忽略它。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]之间选择：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  Marian 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

• head_mask (torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 在编码器中用于使注意力模块中的选定头部失效的掩码。掩码值在[0, 1]之间选择：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 在解码器中用于使注意力模块中的选定头部失效的掩码。掩码值在[0, 1]之间选择：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 在解码器中用于使交叉注意力模块中的选定头部失效的掩码。掩码值在[0, 1]之间选择：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs（tuple(tuple(torch.FloatTensor)，可选）— 元组包括(last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（这些没有将其过去的键值状态提供给此模型）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds（形状为(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可以选择仅输入最后一个decoder_inputs_embeds（参见past_key_values）。如果您想要更多控制权来将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.Seq2SeqModelOutput 或tuple(torch.FloatTensor)

transformers.modeling_outputs.Seq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（MarianConfig）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型解码器最后一层的隐藏状态序列。

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量，以及 2 个额外的形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入层的输出 + 每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

  解码器在每一层输出的隐藏状态以及可选的初始嵌入输出。

• decoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 每一层的 torch.FloatTensor 元组，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 每一层的 torch.FloatTensor 元组，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入层的输出 + 每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

  编码器在每一层输出的隐藏状态以及可选的初始嵌入输出。

• encoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 每一层的 torch.FloatTensor 元组，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

MarianModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例，而不是在此处调用，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, MarianModel

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> model = MarianModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")

>>> inputs = tokenizer("Studies have been shown that owning a dog is good for you", return_tensors="pt")
>>> decoder_inputs = tokenizer(
...     "<pad> Studien haben gezeigt dass es hilfreich ist einen Hund zu besitzen",
...     return_tensors="pt",
...     add_special_tokens=False,
... )
>>> outputs = model(input_ids=inputs.input_ids, decoder_input_ids=decoder_inputs.input_ids)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 26, 512]

MarianMTModel

class transformers.MarianMTModel

< source >

( config: MarianConfig )

参数

• config（MarianConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

具有语言建模头部的 Marian 模型。可用于摘要。该模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（例如下载或保存，调整输入嵌入，修剪头部等）。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Union = None past_key_values: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 输入序列标记在词汇表中的索引。默认情况下将忽略填充。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]：

  • 1 表示未被掩盖的标记，

  • 0 表示被掩盖的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 解码器输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  Marian 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则只需选择最后的decoder_input_ids输入（参见past_key_values）。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。默认情况下还将使用因果掩码。

• head_mask（形状为(encoder_layers, encoder_attention_heads)的torch.Tensor，可选）— 用于使编码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• decoder_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使解码器中注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]：

  • 1 表示头部未被掩盖，

  • 0 表示头部被掩盖。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于在解码器中使交叉注意力模块的特定头部失效的掩码。掩码值选在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包含(last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

  如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果使用了past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（参见past_key_values）。如果您希望更多地控制如何将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

  如果decoder_input_ids和decoder_inputs_embeds都未设置，则decoder_inputs_embeds取inputs_embeds的值。

• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]或-100 之间（参见input_ids文档字符串）。将索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(MarianConfig)和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，optional, 当提供labels时返回) — 语言建模损失。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。

  解码器在每个层的输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。

  编码器在每个层的输出的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

MarianMTModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数中定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

Marian-nmt 的 transformer.h（c++）的 Pytorch 版本。设计用于 OPUS-NMT 翻译检查点。可用模型列在这里。

示例：

>>> from transformers import AutoTokenizer, MarianMTModel

>>> src = "fr"  # source language
>>> trg = "en"  # target language

>>> model_name = f"Helsinki-NLP/opus-mt-{src}-{trg}"
>>> model = MarianMTModel.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

>>> sample_text = "où est l'arrêt de bus ?"
>>> batch = tokenizer([sample_text], return_tensors="pt")

>>> generated_ids = model.generate(**batch)
>>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
"Where's the bus stop?"

MarianForCausalLM

class transformers.MarianForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值选择在[0, 1]之间：

• head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码。

  • 0 表示头部被掩码。

• cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使交叉注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，只有在需要时才需要这两个额外的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码（请参见past_key_values输入）。

  如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（即没有将其过去键值状态提供给此模型的那些）的形状为(batch_size, 1)的输入，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有[0, ..., config.vocab_size]标签的标记。

• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

  • 对于未被masked的标记为 1。

  • 对于被masked的标记为 0。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（MarianConfig）和输入的各种元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个 + 每层输出的一个）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。

• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

  包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

示例：

>>> from transformers import AutoTokenizer, MarianForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-fr-en")
>>> model = MarianForCausalLM.from_pretrained("Helsinki-NLP/opus-mt-fr-en", add_cross_attention=False)
>>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
>>> list(logits.shape) == expected_shape
True

TensorFlowHide TensorFlow content

TFMarianModel

class transformers.TFMarianModel

<来源>

( config: MarianConfig *inputs **kwargs )

参数

• config（MarianConfig） — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 请查看 from_pretrained() 方法以加载模型权重。

裸的 MARIAN 模型输出没有特定头部的原始隐藏状态。 该模型继承自 TFPreTrainedModel。 请查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

该模型也是一个tf.keras.Model子类。 将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有事项。

transformers 中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。 由于这种支持，当使用 model.fit() 等方法时，您应该可以“轻松”地工作 - 只需以 model.fit() 支持的任何格式传递您的输入和标签！ 但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 一个仅包含 input_ids 的单个张量，没有其他内容：model(input_ids)

• 一个变长列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: tf.Tensor | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqModelOutput or tuple(tf.Tensor)

参数

• input_ids (tf.Tensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (tf.Tensor of shape (batch_size, sequence_length), optional) — 遮罩，用于避免在填充标记索引上执行注意力。 遮罩值选择在 [0, 1] 之间：

  • 1 表示“未屏蔽”的标记，

  • 0 表示“屏蔽”的标记。

  什么是注意力遮罩？

• decoder_input_ids (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  Marian 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，可以选择仅输入最后的decoder_input_ids（参见past_key_values）。

• decoder_attention_mask (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 将默认生成并忽略填充标记。不建议为大多数用例设置此项。

• decoder_position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• head_mask (tf.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于将编码器中注意力模块的选定头部置零的掩码。掩码值选定为[0, 1]：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• decoder_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于将解码器中注意力模块的选定头部置零的掩码。掩码值选定为[0, 1]：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• cross_attn_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于将交叉注意力模块的选定头部置零的掩码。掩码值选定为[0, 1]：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs (tf.FloatTensor, optional) — 编码器最后一层的隐藏状态输出。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)的序列

• past_key_values (Tuple[Tuple[tf.Tensor]] of length config.n_layers) — 包含预先计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。

• inputs_embeds (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。

• use_cache (bool, optional, 默认为True) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。

• return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False） — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（MarianConfig）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor） — 模型解码器最后一层的隐藏状态序列。

  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tf.Tensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。

  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每层输出）。

  解码器在每一层输出的隐藏状态以及初始嵌入输出。

• decoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选） — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每层输出）。

  编码器在每一层输出的隐藏状态以及初始嵌入输出。

• encoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFMarianModel 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用 Module 实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFMarianModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> model = TFMarianModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFMarianMTModel

transformers.TFMarianMTModel 类

< source >

( config *inputs **kwargs )

参数

• config (MarianConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

具有语言建模头的 MARIAN 模型。可用于摘要。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

transformers 中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用 model.fit() 等方法时，应该“只需工作” - 只需以 model.fit() 支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 只有一个包含 input_ids 的张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含在文档字符串中给出的顺序中的一个或多个输入张量：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给出的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用 subclassing 创建模型和层时，您无需担心这些问题，因为您可以像对待任何其他 Python 函数一样传递输入！

call

< source >

( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None decoder_position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None cross_attn_head_mask: tf.Tensor | None = None encoder_outputs: TFBaseModelOutput | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• input_ids (tf.Tensor 的形状为 ({0})) — 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask (tf.Tensor of shape ({0}), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示未被掩码的标记，

  • 0 表示标记被掩码。

  什么是注意力掩码？

• decoder_input_ids (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记在词汇表中的索引。

  索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  Marian 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，可以选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

• decoder_attention_mask (tf.Tensor of shape (batch_size, target_sequence_length), optional) — 将默认生成并忽略填充标记。不建议在大多数情况下设置此项。

• decoder_position_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — 解码器输入序列标记在位置嵌入中的位置索引。选在范围 [0, config.max_position_embeddings - 1] 中。

• head_mask (tf.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于使编码器中注意力模块中的特定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被掩码,

  • 0 表示头部被掩码。

• decoder_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 在解码器中用于使注意力模块中的特定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• cross_attn_head_mask (tf.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使交叉注意力模块中的特定头部失效的掩码。掩码值选在 [0, 1] 之间：

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• encoder_outputs (tf.FloatTensor, optional) — 编码器最后一层的输出的隐藏状态。用于解码器的交叉注意力。形状为 (batch_size, sequence_length, hidden_size) 是一个序列

• past_key_values (Tuple[Tuple[tf.Tensor]] of length config.n_layers) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用 past_key_values，用户可以选择仅输入最后的 decoder_input_ids（即未将其过去的键值状态提供给此模型的标记）的形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

• inputs_embeds (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• use_cache (bool, optional, 默认为 True) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。在训练期间设置为 False，在生成期间设置为 True。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, 可选, 默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

• labels (tf.tensor of shape (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应该在 [0, ..., config.vocab_size] 或 -100（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算标签在 [0, ..., config.vocab_size] 中的标记。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（MarianConfig）和输入而异的各种元素。

• loss (tf.Tensor of shape (n,), 可选, 当提供 labels 时返回，其中 n 是未屏蔽标签的数量) — 语言建模损失。

• logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (List[tf.Tensor], 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

  包含解码器的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码（查看 past_key_values 输入）。

• decoder_hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  每层解码器的输出的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

  解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  编码器在每一层的隐藏状态加上初始嵌入输出。

• encoder_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

TFMarianMTModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行前后处理步骤，而后者会默默地忽略它们。

marian-nmt 的 transformer.h（c++）的 TF 版本。设计用于 OPUS-NMT 翻译检查点。可用模型列在这里。

示例：

>>> from transformers import AutoTokenizer, TFMarianMTModel
>>> from typing import List

>>> src = "fr"  # source language
>>> trg = "en"  # target language
>>> sample_text = "où est l'arrêt de bus ?"
>>> model_name = f"Helsinki-NLP/opus-mt-{src}-{trg}"

>>> model = TFMarianMTModel.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)
>>> batch = tokenizer([sample_text], return_tensors="tf")
>>> gen = model.generate(**batch)
>>> tokenizer.batch_decode(gen, skip_special_tokens=True)
"Where is the bus stop ?"

JAX 隐藏 JAX 内容

FlaxMarianModel

class transformers.FlaxMarianModel

<来源>

( config: MarianConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（MarianConfig） — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32） — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了，所有计算将使用给定的dtype进行。

  “请注意，这只指定了计算的数据类型，不会影响模型参数的数据类型。”

  如果希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

裸的 Marian 模型，输出原始的隐藏状态，没有任何特定的头部。这个模型继承自 FlaxPreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

这个模型也是 Flax Linen flax.nn.Module子类。将其用作常规 Flax 模块，并参考 Flax 文档以了解所有与一般用法和行为相关的事项。

最后，这个模型支持 JAX 的内在特性，比如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray）— 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 用于未被“掩码”处理的标记，

  • 0 用于被“掩码”处理的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 词汇表中解码器输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，则模型将根据论文将input_ids向右移动以进行去噪预训练。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果要更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 每个输入序列标记的位置的索引在位置嵌入中。在范围[0, config.max_position_embeddings - 1]中选择。

• decoder_position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 每个解码器输入序列标记的位置的索引在位置嵌入中。在范围[0, config.max_position_embeddings - 1]中选择。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（MarianConfig）和输入不同的元素。

• last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。

  如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。

• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于加速顺序解码（参见past_key_values输入）。

• decoder_hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  每层解码器的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。

  每层编码器的隐藏状态加上初始嵌入输出。

• encoder_attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

FlaxMarianPreTrainedModel的前向方法重写了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FlaxMarianModel

>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> model = FlaxMarianModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FlaxMarianMTModel

class transformers.FlaxMarianMTModel

<来源>

( config: MarianConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

• config（MarianConfig）- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）- 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype执行。

  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

带有语言建模头的 MARIAN 模型。可用于翻译。该模型继承自 FlaxPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型还是 Flax 亚麻flax.nn.Module子类。将其用作常规 Flax 模块，并参考 Flax 文档以获取有关一般用法和行为的所有相关信息。

最后，该模型支持 JAX 的固有功能，例如：

• 即时（JIT）编译

• 自动微分

• 矢量化

• 并行化

__call__

<来源>

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的jnp.ndarray）- 词汇表中输入序列标记的索引。默认情况下将忽略填充。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• attention_mask（形状为(batch_size, sequence_length)的jnp.ndarray，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）- 词汇表中解码器输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是解码器输入 ID？

  对于翻译和摘要训练，应提供decoder_input_ids。如果未提供decoder_input_ids，模型将通过将input_ids向右移动来创建此张量，以进行去噪预训练，遵循论文。

• decoder_attention_mask（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 默认行为：生成一个张量，忽略decoder_input_ids中的填充标记。因果掩码也将默认使用。

  如果您想要更改填充行为，您应该根据自己的需求进行修改。有关默认策略的更多信息，请参见论文中的图表 1。

• position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• decoder_position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 每个解码器输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（MarianConfig）和输入的各种元素。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的jnp.ndarray）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values（tuple(tuple(jnp.ndarray))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。

• decoder_hidden_states（tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。

  每个层输出的解码器的隐藏状态加上初始嵌入输出。

• decoder_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。

• encoder_hidden_states (tuple(jnp.ndarray)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。

  编码器每一层输出的隐藏状态以及初始嵌入输出。

• encoder_attentions (tuple(jnp.ndarray)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。

  编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

FlaxMarianPreTrainedModel的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用Module实例，而不是这个函数，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, FlaxMarianMTModel

>>> model = FlaxMarianMTModel.from_pretrained("Helsinki-NLP/opus-mt-en-de")
>>> tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-de")

>>> text = "My friends are cool but they eat too many carbs."
>>> input_ids = tokenizer(text, max_length=64, return_tensors="jax").input_ids

>>> sequences = model.generate(input_ids, max_length=64, num_beams=2).sequences

>>> outputs = tokenizer.batch_decode(sequences, skip_special_tokens=True)
>>> # should give *Meine Freunde sind cool, aber sie essen zu viele Kohlenhydrate.*

MarkupLM

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/markuplm

概述

MarkupLM 模型是由 Junlong Li、Yiheng Xu、Lei Cui、Furu Wei 在MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding中提出的。MarkupLM 是 BERT，但应用于 HTML 页面而不是原始文本文档。该模型包含额外的嵌入层以提高性能，类似于 LayoutLM。

该模型可用于在网页上进行问答或从网页中提取信息等任务。它在 2 个重要基准测试上取得了最先进的结果：

• WebSRC，这是一个用于基于 Web 的结构化阅读理解的数据集（有点像 SQuAD，但适用于网页）

• SWDE，这是一个用于从网页中提取信息的数据集（基本上是对网页上的命名实体进行识别）

论文摘要如下：

多模态文本、布局和图像的预训练在视觉丰富的文档理解（VrDU）方面取得了显著进展，特别是固定布局文档，如扫描文档图像。然而，仍然有大量数字文档，其中布局信息不固定，需要进行交互和动态呈现以进行可视化，使得现有基于布局的预训练方法不易应用。在本文中，我们提出了 MarkupLM，用于具有标记语言作为骨干的文档理解任务，例如基于 HTML/XML 的文档，其中文本和标记信息是联合预训练的。实验结果表明，预训练的 MarkupLM 在几个文档理解任务上明显优于现有的强基线模型。预训练模型和代码将公开提供。

此模型由nielsr贡献。原始代码可以在这里找到。

使用提示

• 除了input_ids，forward()还需要 2 个额外的输入，即xpath_tags_seq和xpath_subs_seq。这些分别是输入序列中每个标记的 XPATH 标记和下标。

• 可以使用 MarkupLMProcessor 来为模型准备所有数据。有关更多信息，请参考使用指南。

MarkupLM 架构。取自原始论文。

用法：MarkupLMProcessor

为模型准备数据的最简单方法是使用 MarkupLMProcessor，它内部结合了特征提取器（MarkupLMFeatureExtractor）和标记器（MarkupLMTokenizer 或 MarkupLMTokenizerFast）。特征提取器用于从 HTML 字符串中提取所有节点和 XPATH，然后提供给标记器，将它们转换为模型的标记级输入（input_ids等）。请注意，如果您只想处理其中一个任务，仍然可以分别使用特征提取器和标记器。

from transformers import MarkupLMFeatureExtractor, MarkupLMTokenizerFast, MarkupLMProcessor

feature_extractor = MarkupLMFeatureExtractor()
tokenizer = MarkupLMTokenizerFast.from_pretrained("microsoft/markuplm-base")
processor = MarkupLMProcessor(feature_extractor, tokenizer)

简而言之，可以将 HTML 字符串（以及可能的其他数据）提供给 MarkupLMProcessor，它将创建模型所需的输入。在内部，处理器首先使用 MarkupLMFeatureExtractor 获取节点和对应的 xpath 列表。然后将节点和 xpath 提供给 MarkupLMTokenizer 或 MarkupLMTokenizerFast，将它们转换为标记级别的input_ids、attention_mask、token_type_ids、xpath_subs_seq、xpath_tags_seq。可选地，可以向处理器提供节点标签，这些标签将转换为标记级别的labels。

MarkupLMFeatureExtractor 使用 Beautiful Soup，这是一个用于从 HTML 和 XML 文件中提取数据的 Python 库。请注意，您仍然可以使用自己选择的解析解决方案，并将节点和 xpath 自己提供给 MarkupLMTokenizer 或 MarkupLMTokenizerFast。

总共有 5 个由处理器支持的用例。下面我们列出它们。请注意，这些用例适用于批处理和非批处理输入（我们为非批处理输入进行说明）。

用例 1：网页分类（训练，推理）+ 标记分类（推理），parse_html=True

这是最简单的情况，处理器将使用特征提取器从 HTML 中获取所有节点和 xpath。

>>> from transformers import MarkupLMProcessor

>>> processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")

>>> html_string = """
...  <!DOCTYPE html>
...  <html>
...  <head>
...  <title>Hello world</title>
...  </head>
...  <body>
...  <h1>Welcome</h1>
...  <p>Here is my website.</p>
...  </body>
...  </html>"""

>>> # note that you can also add provide all tokenizer parameters here such as padding, truncation
>>> encoding = processor(html_string, return_tensors="pt")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

用例 2：网页分类（训练，推理）+ 标记分类（推理），parse_html=False

如果已经获取了所有节点和 xpath，就不需要特征提取器。在这种情况下，应该将节点和对应的 xpath 自己提供给处理器，并确保将parse_html设置为False。

>>> from transformers import MarkupLMProcessor

>>> processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
>>> processor.parse_html = False

>>> nodes = ["hello", "world", "how", "are"]
>>> xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
>>> encoding = processor(nodes=nodes, xpaths=xpaths, return_tensors="pt")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

用例 3：标记分类（训练），parse_html=False

对于标记分类任务（例如SWDE），还可以提供相应的节点标签以训练模型。处理器将把这些转换为标记级别的labels。默认情况下，它只会标记一个单词的第一个 wordpiece，并用-100 标记剩余的 wordpieces，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。如果您希望标记一个单词的所有 wordpieces，可以将分词器初始化为only_label_first_subword设置为False。

>>> from transformers import MarkupLMProcessor

>>> processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
>>> processor.parse_html = False

>>> nodes = ["hello", "world", "how", "are"]
>>> xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
>>> node_labels = [1, 2, 2, 1]
>>> encoding = processor(nodes=nodes, xpaths=xpaths, node_labels=node_labels, return_tensors="pt")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq', 'labels'])

用例 4：网页问答（推理），parse_html=True

对于网页问答任务，您可以向处理器提供一个问题。默认情况下，处理器将使用特征提取器获取所有节点和 xpath，并创建[CLS]问题标记[SEP]单词标记[SEP]。

>>> from transformers import MarkupLMProcessor

>>> processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")

>>> html_string = """
...  <!DOCTYPE html>
...  <html>
...  <head>
...  <title>Hello world</title>
...  </head>
...  <body>
...  <h1>Welcome</h1>
...  <p>My name is Niels.</p>
...  </body>
...  </html>"""

>>> question = "What's his name?"
>>> encoding = processor(html_string, questions=question, return_tensors="pt")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

用例 5：网页问答（推理），parse_html=False

对于问答任务（例如 WebSRC），您可以向处理器提供一个问题。如果您已经自己提取了所有节点和 xpath，可以直接提供给处理器。请确保将parse_html设置为False。

>>> from transformers import MarkupLMProcessor

>>> processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
>>> processor.parse_html = False

>>> nodes = ["hello", "world", "how", "are"]
>>> xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
>>> question = "What's his name?"
>>> encoding = processor(nodes=nodes, xpaths=xpaths, questions=question, return_tensors="pt")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

资源

• 演示笔记本

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

MarkupLMConfig

class transformers.MarkupLMConfig

< source >

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 bos_token_id = 0 eos_token_id = 2 max_xpath_tag_unit_embeddings = 256 max_xpath_subs_unit_embeddings = 1024 tag_pad_id = 216 subs_pad_id = 1001 xpath_unit_hidden_size = 32 max_depth = 50 position_embedding_type = 'absolute' use_cache = True classifier_dropout = None **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — MarkupLM 模型的词汇表大小。定义了可以由传递给 MarkupLMModel 的 inputs_ids 表示的不同标记。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。

• max_position_embeddings (int, optional, defaults to 512) — 模型可能使用的最大序列长度。通常将其设置为一个较大的值以防万一（例如 512 或 1024 或 2048）。

• type_vocab_size (int, optional, defaults to 2) — 传递给 MarkupLMModel 的 token_type_ids 的词汇表大小。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon 值。

• max_tree_id_unit_embeddings (int, optional, defaults to 1024) — 树 id 单元嵌入可能使用的最大值。通常将其设置为一个较大的值以防万一（例如 1024）。

• max_xpath_tag_unit_embeddings (int, optional, defaults to 256) — xpath 标签单元嵌入可能使用的最大值。通常将其设置为一个较大的值以防万一（例如 256）。

• max_xpath_subs_unit_embeddings (int, optional, defaults to 1024) — xpath 下标单元嵌入可能使用的最大值。通常将其设置为一个较大的值以防万一（例如 1024）。

• tag_pad_id (int, optional, defaults to 216) — xpath 标签中填充标记的 id。

• subs_pad_id (int, optional, defaults to 1001) — xpath 下标中填充标记的 id。

• xpath_tag_unit_hidden_size (int, optional, defaults to 32) — 每个树 id 单元的隐藏大小。一个完整的树索引将具有 (50*xpath_tag_unit_hidden_size) 维度。

• max_depth (int, optional, defaults to 50) — xpath 中的最大深度。

这是用于存储 MarkupLMModel 配置的配置类。根据指定的参数实例化一个 MarkupLM 模型，定义模型架构。使用默认值实例化配置将产生类似于 MarkupLM microsoft/markuplm-base 架构的配置。

配置对象继承自 BertConfig，可用于控制模型输出。阅读 BertConfig 的文档以获取更多信息。

示例：

>>> from transformers import MarkupLMModel, MarkupLMConfig

>>> # Initializing a MarkupLM microsoft/markuplm-base style configuration
>>> configuration = MarkupLMConfig()

>>> # Initializing a model from the microsoft/markuplm-base style configuration
>>> model = MarkupLMModel(configuration)

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

MarkupLMFeatureExtractor

class transformers.MarkupLMFeatureExtractor

< source >

( **kwargs )

构造一个 MarkupLM 特征提取器。这可用于从 HTML 字符串获取节点列表和相应的 XPath。

此特征提取器继承自 PreTrainedFeatureExtractor()，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

__call__

< source >

( html_strings ) → export const metadata = 'undefined';BatchFeature

参数

• html_strings (str, List[str]) — 要提取节点和相应 XPath 的 HTML 字符串或 HTML 字符串批处理。

返回

BatchFeature

一个带有以下字段的 BatchFeature：

• nodes — 节点。

• xpaths — 相应的 XPath。

为模型准备一个或多个 HTML 字符串的主要方法。

示例：

>>> from transformers import MarkupLMFeatureExtractor

>>> page_name_1 = "page1.html"
>>> page_name_2 = "page2.html"
>>> page_name_3 = "page3.html"

>>> with open(page_name_1) as f:
...     single_html_string = f.read()

>>> feature_extractor = MarkupLMFeatureExtractor()

>>> # single example
>>> encoding = feature_extractor(single_html_string)
>>> print(encoding.keys())
>>> # dict_keys(['nodes', 'xpaths'])

>>> # batched example

>>> multi_html_strings = []

>>> with open(page_name_2) as f:
...     multi_html_strings.append(f.read())
>>> with open(page_name_3) as f:
...     multi_html_strings.append(f.read())

>>> encoding = feature_extractor(multi_html_strings)
>>> print(encoding.keys())
>>> # dict_keys(['nodes', 'xpaths'])

MarkupLMTokenizer

class transformers.MarkupLMTokenizer

< source >

( vocab_file merges_file tags_dict errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False max_depth = 50 max_width = 1000 pad_width = 1001 pad_token_label = -100 only_label_first_subword = True **kwargs )

参数

• vocab_file (str) — 词汇表文件的路径。

• merges_file (str) — 合并文件的路径。

• errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅 bytes.decode。

• bos_token (str, optional, defaults to "<s>") — 在预训练期间使用的序列开始标记。可以用作序列分类器标记。

  在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是 cls_token。

• eos_token (str, optional, defaults to "</s>") — 序列结束标记。

  在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是 sep_token。

• sep_token (str, optional, defaults to "</s>") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• cls_token (str, optional, defaults to "<s>") — 在进行序列分类（对整个序列而不是每个标记进行分类）时使用的分类器标记。在使用特殊标记构建序列时，它是序列的第一个标记。

• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• add_prefix_space (bool, optional, defaults to False) — 是否将初始空格添加到输入中。这允许将前导单词视为任何其他单词。（RoBERTa 分词器通过前面的空格检测单词的开头）。

构建一个 MarkupLM 分词器。基于字节级字节对编码（BPE）。MarkupLMTokenizer 可用于将 HTML 字符串转换为标记级input_ids、attention_mask、token_type_ids、xpath_tags_seq和xpath_tags_seq。此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。RoBERTa 序列具有以下格式：

• 单个序列: <s> X </s>

• 序列对: <s> A </s></s> B </s>

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• 从没有添加特殊标记的标记列表中检索序列 ID。在添加时调用此方法 —

• 使用分词器prepare_for_model方法的special标记。— token_ids_0 (List[int]): ID 列表。token_ids_1 (List[int], 可选): 序列对的可选第二个 ID 列表。already_has_special_tokens (bool, 可选, 默认为 False): 标记列表是否已经为模型格式化了特殊标记。

返回

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。

• token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。RoBERTa 不使用标记类型 ID，因此返回一个零列表。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

MarkupLMTokenizerFast

class transformers.MarkupLMTokenizerFast

<来源>

( vocab_file merges_file tags_dict tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False max_depth = 50 max_width = 1000 pad_width = 1001 pad_token_label = -100 only_label_first_subword = True trim_offsets = False **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

• errors (str, 可选, 默认为 "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参见 bytes.decode。

• bos_token (str, 可选, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

  在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是 cls_token。

• eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。

  在使用特殊标记构建序列时，这不是用于序列结尾的标记。使用的标记是 sep_token。

• sep_token (str, optional, defaults to "</s>") — 用于在构建多个序列时使用的分隔符标记，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• cls_token (str, optional, defaults to "<s>") — 在进行序列分类（整个序列的分类而不是每个标记的分类）时使用的分类器标记。在使用特殊标记构建序列时，它是序列的第一个标记。

• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。这是在使用屏蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• add_prefix_space (bool, optional, defaults to False) — 是否在输入中添加初始空格。这允许将前导单词视为任何其他单词。（RoBERTa 分词器通过前面的空格检测单词的开头）。

构建一个 MarkupLM 分词器。基于字节级字节对编码（BPE）。

MarkupLMTokenizerFast 可用于将 HTML 字符串转换为标记级input_ids、attention_mask、token_type_ids、xpath_tags_seq和xpath_tags_seq。此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。

用户应参考此超类以获取有关这些方法的更多信息。

batch_encode_plus

< source >

( batch_text_or_text_pairs: Union is_pair: bool = None xpaths: Optional = None node_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )

add_special_tokens (bool, optional, defaults to True): 在编码序列时是否添加特殊标记。这将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了自动添加到输入 ID 的标记。如果要自动添加bos或eos标记，则这很有用。填充（bool，str或 PaddingStrategy，optional，默认为False）：激活和控制填充。接受以下值：

• True or 'longest': 填充到批处理中最长序列的长度（如果只提供一个序列，则不进行填充）。

• 'max_length': 使用参数max_length指定的最大长度进行填充，或者如果未提供该参数，则使用模型的最大可接受输入长度进行填充。

• False or 'do_not_pad'（默认）：不进行填充（即，可以输出具有不同长度序列的批次）。截断（bool，str或 TruncationStrategy，optional，默认为False）：激活和控制截断。接受以下值：

• True or 'longest_first': 截断到使用参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。这将逐标记截断，如果提供了一对序列（或一批对序列），则从该对中最长序列中删除一个标记。

• 'only_first'：仅截断到由参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批对序列），则仅会截断第一个序列。

• 'only_second': 仅截断到由参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批对序列），则仅会截断第二个序列。

• False或'do_not_truncate'（默认）：无截断（即，可以输出具有大于模型最大可接受输入大小的序列长度的批次）。max_length（int，可选）：由截断/填充参数之一使用的最大长度。

如果未设置或设置为None，则如果截断/填充参数中的一个需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。stride（int，可选，默认为 0）：如果与max_length一起设置为一个数字，则当return_overflowing_tokens=True时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。此参数的值定义了重叠标记的数量。is_split_into_words（bool，可选，默认为False）：输入是否已经预先分词（例如，已经分成单词）。如果设置为True，则分词器会假定输入已经分成单词（例如，通过在空格上分割），然后对其进行标记化。这对于 NER 或标记分类很有用。pad_to_multiple_of（int，可选）：如果设置，将填充序列到提供的值的倍数。需要激活padding。这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。return_tensors（str或 TensorType，可选）：如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

• 'tf'：返回 TensorFlow tf.constant对象。

• 'pt'：返回 PyTorch torch.Tensor对象。

• 'np'：返回 Numpy np.ndarray对象。

add_special_tokens（bool，可选，默认为True）：是否使用相对于其模型的特殊标记对序列进行编码。padding（bool，str或 PaddingStrategy，可选，默认为False）：激活并控制填充。接受以下值：

• True或'longest'：填充到批次中最长的序列（如果只提供了单个序列，则不填充）。

• 'max_length'：填充到由参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。

• False或'do_not_pad'（默认）：无填充（即，可以输出具有不同长度序列的批次）。truncation（bool，str或 TruncationStrategy，可选，默认为False）：激活并控制截断。接受以下值：

• True或'longest_first'：仅截断到由参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批对序列），则将逐标记截断，从一对序列中删除最长序列的一个标记。

• 'only_first': 如果提供了参数max_length，则截断到指定的最大长度，或者截断到模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批序列对），则只会截断第一个序列。

• 'only_second': 如果提供了参数max_length，则截断到指定的最大长度，或者截断到模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批序列对），则只会截断第二个序列。

• False或'do_not_truncate'（默认）: 不截断（即，可以输出长度大于模型最大可接受输入大小的批处理）。max_length（int，可选）: 通过截断/填充参数之一控制要使用的最大长度。如果未设置或设置为None，则将使用预定义的模型最大长度（如果截断/填充参数需要最大长度）。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。stride（int，可选，默认为 0）: 如果与max_length一起设置为一个数字，则当return_overflowing_tokens=True时返回的溢出标记将包含从截断序列末尾返回的一些标记，以提供截断和溢出序列之间的一些重叠。此参数的值定义了重叠标记的数量。pad_to_multiple_of（int，可选）: 如果设置，将填充序列到提供的值的倍数。这对于在具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。return_tensors（str或 TensorType，可选）: 如果设置，将返回张量而不是 Python 整数列表。可接受的值为:

• 'tf': 返回 TensorFlow tf.constant对象。

• 'pt': 返回 PyTorch torch.Tensor对象。

• 'np': 返回 Numpy np.ndarray对象。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— 将添加特殊标记的 ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

带有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。RoBERTa 序列的格式如下：

• 单个序列: <s> X </s>

• 序列对: <s> A </s></s> B </s>

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）— ID 列表。

• token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

返回

List[int]

零列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。RoBERTa 不使用 token 类型 ID，因此返回一个零列表。

encode_plus

<来源>

( text: Union text_pair: Optional = None xpaths: Optional = None node_labels: Optional = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )

参数

• text（str，List[str]，List[List[str]]）— 要编码的第一个序列。这可以是一个字符串，一个字符串列表或一个字符串列表的列表。

• text_pair（List[str]或List[int]，可选）— 要编码的可选第二个序列。这可以是一个字符串列表（单个示例的单词）或一个字符串列表的列表（一批示例的单词）。

• add_special_tokens (bool, 可选, 默认为 True) — 在编码序列时是否添加特殊标记。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了自动添加到输入 id 的标记。如果要自动添加 bos 或 eos 标记，则这很有用。

• padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值：

  • True 或 'longest': 填充到批次中最长的序列（或者如果只提供了单个序列，则不填充）。

  • 'max_length': 填充到由参数 max_length 指定的最大长度，或者填充到模型可接受的最大输入长度（如果未提供该参数）。

  • False 或 'do_not_pad'（默认）: 不填充（即，可以输出具有不同长度序列的批次）。

• truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活和控制截断。接受以下值：

  • True 或 'longest_first': 截断到由参数 max_length 指定的最大长度，或者截断到模型可接受的最大输入长度（如果未提供该参数）。如果提供了一对序列（或一批序列），则将逐个标记截断，从该对中最长的序列中删除一个标记。

  • 'only_first': 截断到由参数 max_length 指定的最大长度，或者截断到模型可接受的最大输入长度（如果未提供该参数）。如果提供了一对序列（或一批序列），则仅截断第一个序列。

  • 'only_second': 截断到由参数 max_length 指定的最大长度，或者截断到模型可接受的最大输入长度（如果未提供该参数）。如果提供了一对序列（或一批序列），则仅截断第二个序列。

  • False 或 'do_not_truncate'（默认）: 不截断（即，可以输出具有大于模型最大可接受输入大小的序列长度的批次）。

• max_length (int, 可选) — 由截断/填充参数之一使用的最大长度。

  如果未设置或设置为 None，则如果截断/填充参数中的一个需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。

• stride (int, 可选, 默认为 0) — 如果与 max_length 一起设置为一个数字，则当 return_overflowing_tokens=True 时，返回的溢出标记将包含从截断序列末尾返回的一些标记，以提供截断和溢出序列之间的一些重叠。此参数的值定义重叠标记的数量。

• is_split_into_words (bool, 可选, 默认为 False) — 输入是否已经预分词化（例如，已分割为单词）。如果设置为 True，则分词器会假定输入已经分割为单词（例如，通过在空格上分割），然后对其进行分词。这对于 NER 或标记分类很有用。

• pad_to_multiple_of (int, 可选) — 如果设置，将填充序列到提供的值的倍数。需要激活 padding。这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用，计算能力 >= 7.5（Volta）。

• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant 对象。

  • 'pt': 返回 PyTorch torch.Tensor 对象。

  • 'np': 返回 Numpy np.ndarray 对象。

• add_special_tokens (bool, 可选, 默认为 True) — 是否对序列进行编码，使用相对于其模型的特殊标记。

• padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值:

  • True 或 'longest': 填充到批次中最长的序列（如果只提供一个序列，则不填充）。

  • 'max_length': 填充到使用参数 max_length 指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。

  • False 或 'do_not_pad'（默认）: 不填充（即，可以输出长度不同的序列批次）。

• truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活和控制截断。接受以下值:

  • True 或 'longest_first': 截断到使用参数 max_length 指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批对序列），则将逐标记截断，从一对序列中最长的序列中移除一个标记。

  • 'only_first': 截断到使用参数 max_length 指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批对序列），则只会截断第一个序列。

  • 'only_second': 截断到使用参数 max_length 指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批对序列），则只会截断第二个序列。

  • False 或 'do_not_truncate'（默认）: 不截断（即，可以输出长度大于模型最大可接受输入大小的序列批次）。

• max_length (int, 可选) — 控制截断/填充参数之一使用的最大长度。如果未设置或设置为 None，则将使用预定义的模型最大长度，如果截断/填充参数需要最大长度。如果模型没有特定的最大输入长度（如 XLNet）则截断/填充到最大长度将被禁用。

• stride (int, 可选, 默认为 0) — 如果设置为一个数字，并且 max_length 一起设置，当 return_overflowing_tokens=True 时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。此参数的值定义了重叠标记的数量。

• pad_to_multiple_of (int, 可选) — 如果设置，将填充序列到提供的值的倍数。这对于启用 NVIDIA 硬件上的 Tensor Cores 特别有用，计算能力 >= 7.5（Volta）。

• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为:

  • 'tf': 返回 TensorFlow tf.constant 对象。

  • 'pt': 返回 PyTorch torch.Tensor 对象。

  • 'np': 返回 Numpy np.ndarray 对象。

对一个序列或一对序列进行标记化和准备模型。… 警告:: 此方法已弃用，应改用 __call__。

get_xpath_seq

< source >

( xpath )

给定一个特定节点的 xpath 表达式（如“/html/body/div/li[1]/div/span[2]”），返回一个考虑最大深度的标签 ID 列表和相应的下标。

MarkupLMProcessor

class transformers.MarkupLMProcessor

< source >

( *args **kwargs )

参数

• feature_extractor (MarkupLMFeatureExtractor) — MarkupLMFeatureExtractor 的实例。特征提取器是必需的输入。

• tokenizer (MarkupLMTokenizer 或 MarkupLMTokenizerFast) — MarkupLMTokenizer 或 MarkupLMTokenizerFast 的实例。分词器是必需的输入。

• parse_html (bool, optional, 默认为 True) — 是否使用 MarkupLMFeatureExtractor 来解析 HTML 字符串为节点和对应的 xpath。

构建一个将 MarkupLM 特征提取器和 MarkupLM 分词器合并为单个处理器的 MarkupLM 处理器。

MarkupLMProcessor 提供了准备模型数据所需的所有功能。

首先使用 MarkupLMFeatureExtractor 从一个或多个 HTML 字符串中提取节点和对应的 xpath。接下来，将它们提供给 MarkupLMTokenizer 或 MarkupLMTokenizerFast，将它们转换为标记级别的 input_ids、attention_mask、token_type_ids、xpath_tags_seq 和 xpath_subs_seq。

__call__

< source >

( html_strings = None nodes = None xpaths = None node_labels = None questions = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

该方法首先将 html_strings 参数转发到 call()。接下来，将 nodes 和 xpaths 与其他参数一起传递给 __call__() 并返回输出。

可选地，还可以提供一个 text 参数，作为第一个序列传递。

请参考上述两个方法的文档字符串以获取更多信息。

MarkupLMModel

class transformers.MarkupLMModel

< source >

( config add_pooling_layer = True )

参数

• config (MarkupLMConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 MarkupLM 模型，输出原始隐藏状态而不带任何特定的头部。该模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None xpath_tags_seq: Optional = None xpath_subs_seq: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• xpath_tags_seq（torch.LongTensor，形状为(batch_size, sequence_length, config.max_depth)，可选）— 输入序列中每个标记的标记 ID，填充至 config.max_depth。

• xpath_subs_seq（torch.LongTensor，形状为(batch_size, sequence_length, config.max_depth)，可选）— 输入序列中每个标记的下标 ID，填充至 config.max_depth。

• attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：对于未被 MASK 的标记为1，对于 MASK 标记为0。

  什么是注意力掩码？

• token_type_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：0对应于sentence A标记，1对应于sentence B标记

  什么是标记类型 ID？

• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]内。

  什么是位置 ID？

• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块的选定头部失效的掩码。选择在[0, 1]范围内的掩码值：1表示头部未被掩码，0表示头部被掩码。

• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 如果设置为True，模型将返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（MarkupLMConfig）和输入。

• last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)）— 模型最后一层的隐藏状态输出的序列。

• pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后，序列第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

• hidden_states (tuple(torch.FloatTensor), 可选的，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 + 每层的输出），形状为(batch_size, sequence_length, hidden_size)。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), 可选的，当传递output_attentions=True或config.output_attentions=True时返回） — 每个层的torch.FloatTensor元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。

  注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_attentions (tuple(torch.FloatTensor), 可选的，当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回） — 每个层的torch.FloatTensor元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。

  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

• past_key_values (tuple(tuple(torch.FloatTensor)), 可选的，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值，以及如果config.is_encoder_decoder=True在交叉注意力块中）可用（参见past_key_values输入）以加速顺序解码。

MarkupLMModel 的前向方法覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, MarkupLMModel

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> model = MarkupLMModel.from_pretrained("microsoft/markuplm-base")

>>> html_string = "<html> <head> <title>Page Title</title> </head> </html>"

>>> encoding = processor(html_string, return_tensors="pt")

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 4, 768]

MarkupLMForSequenceClassification

class transformers.MarkupLMForSequenceClassification

<来源>

( config )

参数

• config (MarkupLMConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部序列分类/回归头（池化输出顶部的线性层）的 MarkupLM 模型变换器，例如用于 GLUE 任务。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None xpath_tags_seq: Optional = None xpath_subs_seq: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• xpath_tags_seq (torch.LongTensor，形状为 (batch_size, sequence_length, config.max_depth)，optional) — 输入序列中每个标记的标记 ID，填充至 config.max_depth。

• xpath_subs_seq (torch.LongTensor，形状为 (batch_size, sequence_length, config.max_depth)，optional) — 输入序列中每个标记的下标 ID，填充至 config.max_depth。

• attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，optional) — 用于避免对填充标记索引执行注意力的掩码。选择的掩码值在 [0, 1] 中：1 表示未被掩码的标记，0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：0 对应于 句子 A 标记，1 对应于 句子 B 标记

  什么是标记类型 ID？

• position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，optional) — 每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。选择的掩码值在 [0, 1] 中：1 表示头部未被掩码，0 表示头部被掩码。

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望更多地控制如何将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool，optional) — 如果设置为 True，则返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 如果设置为 True，则返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

• return_dict (bool，optional) — 如果设置为 True，模型将返回一个 ModelOutput，而不是一个普通的元组。

• labels (torch.LongTensor，形状为 (batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（MarkupLMConfig）和输入的各种元素。

• 损失 (torch.FloatTensor 的形状为 (1,)，可选，当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。

• logits (torch.FloatTensor 的形状为 (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入的输出 + 每个层的输出）。

  每层模型的隐藏状态加上可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。

  自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

MarkupLMForSequenceClassification 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用 Module 实例而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, AutoModelForSequenceClassification
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> model = AutoModelForSequenceClassification.from_pretrained("microsoft/markuplm-base", num_labels=7)

>>> html_string = "<html> <head> <title>Page Title</title> </head> </html>"
>>> encoding = processor(html_string, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> loss = outputs.loss
>>> logits = outputs.logits

MarkupLMForTokenClassification

class transformers.MarkupLMForTokenClassification

< source >

( config )

参数

• config (MarkupLMConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

在顶部有一个 token_classification 头的 MarkupLM 模型。这个模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< source >

( input_ids: Optional = None xpath_tags_seq: Optional = None xpath_subs_seq: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor 的形状为 (batch_size, sequence_length)） — 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• xpath_tags_seq (torch.LongTensor 的形状为 (batch_size, sequence_length, config.max_depth)，可选) — 输入序列中每个标记的标签 ID，填充至 config.max_depth。

• xpath_subs_seq (torch.LongTensor of shape (batch_size, sequence_length, config.max_depth), optional) — 输入序列中每个标记的下标 ID，填充至 config.max_depth。

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的遮罩。遮罩值选择在[0, 1]范围内：1表示未被遮罩的标记，0表示被遮罩的标记。

  什么是注意力遮罩？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]范围内：0对应于句子 A标记，1对应于句子 B标记

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的选定头部失效的遮罩。遮罩值选择在[0, 1]范围内：1表示头部未被遮罩，0表示头部被遮罩。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool, optional) — 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool, optional) — 如果设置为True，模型将返回一个 ModelOutput，而不是一个普通的元组。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

返回

transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，这取决于配置（MarkupLMConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 掩码语言建模（MLM）损失。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出，则为一个，每层的输出为一个）。

  每层模型的隐藏状态以及可选的初始嵌入输出。

• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

MarkupLMForTokenClassification 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, AutoModelForTokenClassification
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> processor.parse_html = False
>>> model = AutoModelForTokenClassification.from_pretrained("microsoft/markuplm-base", num_labels=7)

>>> nodes = ["hello", "world"]
>>> xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span"]
>>> node_labels = [1, 2]
>>> encoding = processor(nodes=nodes, xpaths=xpaths, node_labels=node_labels, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> loss = outputs.loss
>>> logits = outputs.logits

MarkupLMForQuestionAnswering

class transformers.MarkupLMForQuestionAnswering

<来源>

( config )

参数

• config（MarkupLMConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有跨度分类头的 MarkupLM 模型，用于提取式问答任务，如 SQuAD（在隐藏状态输出的顶部进行线性层计算span start logits和span end logits）。

该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None xpath_tags_seq: Optional = None xpath_subs_seq: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

• xpath_tags_seq（torch.LongTensor，形状为(batch_size, sequence_length, config.max_depth)，可选）- 输入序列中每个标记的标签 ID，填充至 config.max_depth。

• xpath_subs_seq（torch.LongTensor，形状为(batch_size, sequence_length, config.max_depth)，可选）- 每个输入序列中每个标记的下标 ID，填充至 config.max_depth。

• attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：1表示未屏蔽的标记，0表示已屏蔽的标记。

  什么是注意力掩码？

• token_type_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：0对应于句子 A标记，1对应于句子 B标记

  什么是标记类型 ID？

• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的选定头部失效的掩码。在[0, 1]中选择的掩码值：1表示头部未被掩码，0表示头部被掩码。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 如果设置为True，模型将返回一个 ModelOutput，而不是一个普通的元组。

• start_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记跨度开始位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内，用于计算损失。

• end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记跨度结束位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内，用于计算损失。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（MarkupLMConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

• start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — Span-start scores (before SoftMax).

• end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — Span-end scores (before SoftMax).

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出加上每层的输出）。

  模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

MarkupLMForQuestionAnswering 的前向方法重写了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, MarkupLMForQuestionAnswering
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base-finetuned-websrc")
>>> model = MarkupLMForQuestionAnswering.from_pretrained("microsoft/markuplm-base-finetuned-websrc")

>>> html_string = "<html> <head> <title>My name is Niels</title> </head> </html>"
>>> question = "What's his name?"

>>> encoding = processor(html_string, questions=question, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = encoding.input_ids[0, answer_start_index : answer_end_index + 1]
>>> processor.decode(predict_answer_tokens).strip()
'Niels'

m_layers, num_heads), *optional*) — 用于使自注意力模块中的选定头部失效的掩码。在[0, 1]中选择的掩码值：1表示头部**未被掩码**，0`表示头部被掩码。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states (bool, optional) — 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict (bool, optional) — 如果设置为True，模型将返回一个 ModelOutput，而不是一个普通的元组。

• start_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记跨度开始位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内，用于计算损失。

• end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记跨度结束位置的位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内，用于计算损失。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（MarkupLMConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

• start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — Span-start scores (before SoftMax).

• end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — Span-end scores (before SoftMax).

• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出加上每层的输出）。

  模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

MarkupLMForQuestionAnswering 的前向方法重写了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, MarkupLMForQuestionAnswering
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base-finetuned-websrc")
>>> model = MarkupLMForQuestionAnswering.from_pretrained("microsoft/markuplm-base-finetuned-websrc")

>>> html_string = "<html> <head> <title>My name is Niels</title> </head> </html>"
>>> question = "What's his name?"

>>> encoding = processor(html_string, questions=question, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = encoding.input_ids[0, answer_start_index : answer_end_index + 1]
>>> processor.decode(predict_answer_tokens).strip()
'Niels'