Transformers 文档
UDOP
并获得增强的文档体验
开始使用
UDOP
概述
UDOP 模型在 Unifying Vision, Text, and Layout for Universal Document Processing 中提出，作者为 Zineng Tang、Ziyi Yang、Guoxin Wang、Yuwei Fang、Yang Liu、Chenguang Zhu、Michael Zeng、Cha Zhang、Mohit Bansal。UDOP 采用了基于 T5 的编码器-解码器 Transformer 架构，用于文档 AI 任务，如文档图像分类、文档解析和文档视觉问答。
该论文的摘要如下：
我们提出了通用文档处理 (UDOP)，这是一个基础文档 AI 模型，它统一了文本、图像和布局模态，以及包括文档理解和生成在内的各种任务格式。UDOP 利用文本内容和文档图像之间的空间相关性，用统一的表示来建模图像、文本和布局模态。借助新颖的视觉-文本-布局 Transformer，UDOP 将预训练和多领域下游任务统一到基于提示的序列生成方案中。UDOP 在大规模无标签文档语料库上使用创新的自监督目标进行预训练，也在各种带标签数据上进行预训练。UDOP 还学习通过掩码图像重建从文本和布局模态生成文档图像。据我们所知，这是文档 AI 领域首次有模型同时实现高质量的神经文档编辑和内容定制。我们的方法在 9 个文档 AI 任务（例如，文档理解和 QA）上创造了最先进水平，涵盖了金融报告、学术论文和网站等不同的数据领域。UDOP 在文档理解基准 (DUE) 的排行榜上名列第一。*
UDOP 架构。取自 原始论文。使用技巧
- 除了 input_ids，UdopForConditionalGeneration 还期望输入
bbox，即输入标记的边界框（即 2D 位置）。这些可以使用外部 OCR 引擎获得，例如 Google 的 Tesseract（有一个 Python 封装器 可用）。每个边界框应采用 (x0, y0, x1, y1) 格式，其中 (x0, y0) 对应于边界框中左上角的位置，(x1, y1) 表示右下角的位置。请注意，首先需要将边界框归一化到 0-1000 比例。要归一化，可以使用以下函数
def normalize_bbox(bbox, width, height):
return [
int(1000 * (bbox[0] / width)),
int(1000 * (bbox[1] / height)),
int(1000 * (bbox[2] / width)),
int(1000 * (bbox[3] / height)),
]在此，width 和 height 对应于标记出现的原始文档的宽度和高度。这些可以使用 Python Image Library (PIL) 库获得，例如，如下所示
from PIL import Image
# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")
width, height = image.size可以使用 UdopProcessor 为模型准备图像和文本，它可以处理所有这些。默认情况下，此类使用 Tesseract 引擎从给定文档中提取单词和框（坐标）列表。它的功能与 LayoutLMv3Processor 的功能相同，因此它支持传递 apply_ocr=False（如果您希望使用自己的 OCR 引擎）或 apply_ocr=True（如果您希望使用默认的 OCR 引擎）。有关所有可能的用例，请参阅 LayoutLMv2 的使用指南（UdopProcessor 的功能是相同的）。
- 如果使用自己选择的 OCR 引擎，一个建议是 Azure 的 Read API，它支持所谓的线段。使用段位置嵌入通常会带来更好的性能。
- 在推理时，建议使用
generate方法来自动回归地生成给定文档图像的文本。 - 该模型已在自监督和监督目标上进行了预训练。可以使用预训练期间使用的各种任务前缀（提示）来测试开箱即用的功能。例如，可以使用 “Question answering. What is the date?” 提示模型，因为 “Question answering.” 是 DocVQA 预训练期间使用的任务前缀。有关所有任务前缀，请参阅 论文（表 1）。
- 还可以微调 UdopEncoderModel，它是 UDOP 的仅编码器部分，可以看作是类似 LayoutLMv3 的 Transformer 编码器。对于判别任务，只需在其之上添加一个线性分类器，并在带标签的数据集上对其进行微调即可。
资源
官方 Hugging Face 和社区（🌎 表示）资源列表，可帮助您开始使用 UDOP。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！资源最好展示一些新的东西，而不是重复现有的资源。
UdopConfig
class transformers.UdopConfig
< source >( vocab_size = 33201 d_model = 1024 d_kv = 64 d_ff = 4096 num_layers = 24 num_decoder_layers = None num_heads = 16 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 relative_bias_args = [{'type': '1d'}, {'type': 'horizontal'}, {'type': 'vertical'}] dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'relu' is_encoder_decoder = True use_cache = True pad_token_id = 0 eos_token_id = 1 max_2d_position_embeddings = 1024 image_size = 224 patch_size = 16 num_channels = 3 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 33201) — UDOP 模型的词汇表大小。定义了调用 UdopForConditionalGeneration 时传递的inputs_ids可以表示的不同标记的数量。 - d_model (
int, 可选, 默认为 1024) — 编码器层和池化层的大小。 - d_kv (
int, 可选, 默认为 64) — 每个注意力头的键、查询、值投影的大小。 投影层的inner_dim将定义为num_heads * d_kv。 - d_ff (
int, 可选, 默认为 4096) — 每个UdopBlock中间前馈层的大小。 - num_layers (
int, 可选, 默认为 24) — Transformer 编码器和解码器中隐藏层的数量。 - num_decoder_layers (
int, 可选) — Transformer 解码器中隐藏层的数量。 如果未设置，将使用与num_layers相同的值。 - num_heads (
int, 可选, 默认为 16) — Transformer 编码器和解码器中每个注意力层的注意力头数。 - relative_attention_num_buckets (
int, 可选, 默认为 32) — 每个注意力层使用的桶的数量。 - relative_attention_max_distance (
int, 可选, 默认为 128) — 用于桶分离的较长序列的最大距离。 - relative_bias_args (
List[dict], 可选, 默认为[{'type' -- '1d'}, {'type': 'horizontal'}, {'type': 'vertical'}]): 包含相对偏置层参数的字典列表。 - dropout_rate (
float, 可选, 默认为 0.1) — 所有 dropout 层的比率。 - layer_norm_epsilon (
float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon 值。 - initializer_factor (
float, 可选, 默认为 1.0) — 初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。 - feed_forward_proj (
string, 可选, 默认为"relu") — 要使用的前馈层类型。 应该为"relu"或"gated-gelu"之一。 Udopv1.1 使用"gated-gelu"前馈投影。 原始 Udop 使用"relu"。 - is_encoder_decoder (
bool, 可选, 默认为True) — 模型是否应表现为编码器/解码器。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回上次的键/值注意力 (并非所有模型都使用)。 - pad_token_id (
int, 可选, 默认为 0) — 词汇表中填充标记的 ID。 - eos_token_id (
int, 可选, 默认为 1) — 词汇表中序列结束标记的 ID。 - max_2d_position_embeddings (
int, 可选, 默认为 1024) — 相对位置编码的最大绝对位置嵌入。 - image_size (
int, 可选, 默认为 224) — 输入图像的大小。 - patch_size (
int, 可选, 默认为 16) — 视觉编码器使用的 patch 大小。 - num_channels (
int, 可选, 默认为 3) — 输入图像中的通道数。
这是用于存储 UdopForConditionalGeneration 配置的配置类。 它用于根据指定的参数实例化 UDOP 模型，定义模型架构。 使用默认值实例化配置将产生与 UDOP microsoft/udop-large 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 阅读 PretrainedConfig 的文档以获取更多信息。
UdopTokenizer
class transformers.UdopTokenizer
< source >( vocab_file eos_token = '</s>' unk_token = '<unk>' sep_token = '</s>' pad_token = '<pad>' sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True additional_special_tokens = None sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None legacy = True add_prefix_space = True **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。 使用的标记是
sep_token。 - unk_token (
str, 可选, 默认为"<unk>") — 未知标记。 词汇表中不存在的标记无法转换为 ID，而是设置为此标记。 - sep_token (
str, 可选, 默认为"</s>") — 分隔符标记，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。 它也用作使用特殊标记构建的序列的最后一个标记。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充的标记，例如当批处理不同长度的序列时。 - sep_token_box (
List[int], optional, 默认为[1000, 1000, 1000, 1000]) — 用于特殊 [SEP] token 的边界框。 - pad_token_box (
List[int], optional, 默认为[0, 0, 0, 0]) — 用于特殊 [PAD] token 的边界框。 - pad_token_label (
int, optional, 默认为 -100) — 用于 padding tokens 的标签。默认为 -100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。 - only_label_first_subword (
bool, optional, 默认为True) — 是否仅标记第一个子词，以防提供单词标签。 - additional_special_tokens (
List[str], optional, 默认为["<s>NOTUSED", "</s>NOTUSED"]) — tokenizer 使用的其他特殊 token。 - sp_model_kwargs (
dict, optional) — 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 封装器 可以用于设置以下内容（包括其他内容）：-
enable_sampling: 启用 subword regularization。 -
nbest_size: unigram 的采样参数。对 BPE-Dropout 无效。nbest_size = {0,1}: 不执行采样。nbest_size > 1: 从 nbest_size 结果中采样。nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（lattice）中采样。
-
alpha: 用于 unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
-
- legacy (
bool, optional, 默认为True) — 是否应使用 tokenizer 的legacy行为。Legacy 是指在合并 #24622 之前的版本，该版本包含修复程序，以正确处理特殊 token 之后出现的 token。一个简单的例子：legacy=True:
改编自 LayoutXLMTokenizer 和 T5Tokenizer。基于 SentencePiece。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
参数
- token_ids_0 (
List[int]) — 将向其添加特殊 token 的 ID 列表。 - token_ids_1 (
List[int], optional) — 序列对的可选第二个 ID 列表。
返回
List[int]
带有适当特殊 token 的 输入 ID 列表。
通过连接和添加特殊 token，从序列或序列对构建模型输入，以用于序列分类任务。序列具有以下格式
- 单个序列：
X </s> - 序列对：
A </s> B </s>
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊 token 的 token 列表中检索序列 ID。当使用 tokenizer 的 prepare_for_model 方法添加特殊 token 时，会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建一个 mask，用于序列对分类任务。T5 不使用 token 类型 ID，因此返回零列表。
UdopTokenizerFast
class transformers.UdopTokenizerFast
< source >( vocab_file = None tokenizer_file = None eos_token = '</s>' sep_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True additional_special_tokens = None **kwargs )
参数
- vocab_file (
str, optional) — 词汇表文件的路径。 - tokenizer_file (
str, optional) — tokenizer 文件的路径。 - eos_token (
str, optional, 默认为"</s>") — 序列结束 token。当使用特殊 token 构建序列时，这不是用于序列结尾的 token。使用的 token 是
sep_token。 - sep_token (
str, optional, 默认为"</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 - unk_token (
str, optional, 默认为"<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是设置为此 token。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充的 token，例如在批量处理不同长度的序列时使用。 - sep_token_box (
List[int], 可选, 默认为[1000, 1000, 1000, 1000]) — 用于特殊 [SEP] token 的边界框。 - pad_token_box (
List[int], 可选, 默认为[0, 0, 0, 0]) — 用于特殊 [PAD] token 的边界框。 - pad_token_label (
int, 可选, 默认为 -100) — 用于填充 token 的标签。默认为 -100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。 - only_label_first_subword (
bool, 可选, 默认为True) — 是否仅标记第一个子词，以防提供单词标签。 - additional_special_tokens (
List[str], 可选, 默认为["<s>NOTUSED", "</s>NOTUSED"]) — tokenizer 使用的其他特殊 token。
构建一个 “fast” UDOP tokenizer（由 HuggingFace 的 tokenizers 库支持）。改编自 LayoutXLMTokenizer 和 T5Tokenizer。基于 BPE。
此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
batch_encode_plus_boxes
< 源代码 >( batch_text_or_text_pairs: typing.Union[typing.List[str], typing.List[typing.Tuple[str, str]], typing.List[typing.List[str]]] is_pair: bool = None boxes: typing.Optional[typing.List[typing.List[typing.List[int]]]] = None word_labels: typing.Optional[typing.List[typing.List[int]]] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = 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 )
对序列列表或序列对列表进行 tokenization 并为模型准备。
此方法已弃用，应使用 __call__ 代替。
build_inputs_with_special_tokens
< 源代码 >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
通过连接和添加特殊 token，从序列或序列对构建用于序列分类任务的模型输入。XLM-RoBERTa 序列具有以下格式
- 单个序列:
<s> X </s> - 序列对:
<s> A </s></s> B </s>
call_boxes
< 源代码 >( text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] text_pair: typing.Union[typing.List[str], typing.List[typing.List[str]], NoneType] = None boxes: typing.Union[typing.List[typing.List[int]], typing.List[typing.List[typing.List[int]]]] = None word_labels: typing.Union[typing.List[int], typing.List[typing.List[int]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = 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 ) → BatchEncoding
参数
- text (
str,List[str],List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串、字符串列表（单个示例的单词或一批示例的问题）或字符串列表的列表（单词批次）。 - text_pair (
List[str],List[List[str]]) — 要编码的序列或序列批次。每个序列都应该是字符串列表（预 tokenized 字符串）。 - boxes (
List[List[int]],List[List[List[int]]]) — 单词级别的边界框。每个边界框都应标准化为 0-1000 范围。 - word_labels (
List[int],List[List[int]], 可选) — 单词级别的整数标签（用于 token 分类任务，例如 FUNSD、CORD）。 - add_special_tokens (
bool, 可选, 默认为True) — 是否使用与其模型相关的特殊 token 对序列进行编码。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 激活并控制 padding。接受以下值：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充到通过参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'（默认）：不进行填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认为False) — 激活并控制截断。接受以下值：True或'longest_first': 截断到通过参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型可接受的最大输入长度。这将逐 token 进行截断，如果提供了一对序列（或一批序列对），则从较长序列中移除 token。'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时返回的溢出 token 将包含来自截断序列末尾的一些 token，以便在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, 可选) — 如果设置，将序列填充到提供值的倍数。这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用尤其有用。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensors 而不是 Python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回 token type IDs。如果保留为默认值，将根据特定 tokenizer 的默认值（由return_outputs属性定义）返回 token type IDs。 - return_attention_mask (
bool, 可选) — 是否返回 attention mask。如果保留为默认值，将根据特定 tokenizer 的默认值（由return_outputs属性定义）返回 attention mask。 - return_overflowing_tokens (
bool, 可选, 默认为False) — 是否返回溢出的 token 序列。如果提供了一对输入 id 序列（或一批序列对）且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool, 可选, 默认为False) — 是否返回 special tokens mask 信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回每个 token 的(char_start, char_end)。这仅在继承自 PreTrainedTokenizerFast 的快速 tokenizer 上可用，如果使用 Python 的 tokenizer，此方法将引发
NotImplementedError。 - return_length (
bool, 可选, 默认为False) — 是否返回编码输入的长度。 - verbose (
bool, 可选, 默认为True) — 是否打印更多信息和警告。 - **kwargs — 传递给
self.tokenize()方法
一个 BatchEncoding，包含以下字段
-
input_ids — 要馈送到模型的 token id 列表。
-
bbox — 要馈送到模型的 bounding box 列表。
-
token_type_ids — 要馈送到模型的 token type id 列表 (当
return_token_type_ids=True或如果 “token_type_ids” 在self.model_input_names中时)。 -
attention_mask — 指定模型应关注哪些 token 的索引列表 (当
return_attention_mask=True或如果 “attention_mask” 在self.model_input_names中时)。 -
labels — 要馈送到模型的 label 列表。（当指定
word_labels时）。 -
overflowing_tokens — 溢出的 token 序列列表（当指定
max_length且return_overflowing_tokens=True时）。 -
num_truncated_tokens — 截断的 token 数量（当指定
max_length且return_overflowing_tokens=True时）。 -
special_tokens_mask — 0 和 1 的列表，其中 1 指定添加的特殊 token，0 指定常规序列 token (当
add_special_tokens=True且return_special_tokens_mask=True时)。 -
length — 输入的长度 (当
return_length=True时)。
用于 token 化并为模型准备一个或多个序列或一对或多对序列的主要方法，带有单词级归一化 bounding boxes 和可选的 labels。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建一个 mask，用于序列对分类任务。 XLM-RoBERTa 不使用 token type id，因此返回零列表。
encode_boxes
< source >( text: typing.Union[str, typing.List[str], typing.List[int]] text_pair: typing.Union[str, typing.List[str], typing.List[int], NoneType] = None boxes: typing.Optional[typing.List[typing.List[int]]] = None word_labels: typing.Optional[typing.List[typing.List[int]]] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None **kwargs )
参数
- Converts 将字符串转换为 id 序列（整数），使用 tokenizer 和词汇表。与执行以下操作相同 —
-
self.convert_tokens_to_ids(self.tokenize(text))。 — text (str,List[str]或List[int]): 要编码的第一个序列。这可以是字符串、字符串列表（使用tokenize方法 token 化的字符串）或整数列表（使用convert_tokens_to_ids方法 token 化的字符串 id）。 text_pair (str,List[str]或List[int], 可选): 要编码的可选第二个序列。这可以是字符串、字符串列表（使用tokenize方法 token 化的字符串）或整数列表（使用convert_tokens_to_ids方法 token 化的字符串 id）。
encode_plus_boxes
< source >( text: typing.Union[str, typing.List[str]] text_pair: typing.Optional[typing.List[str]] = None boxes: typing.Optional[typing.List[typing.List[int]]] = None word_labels: typing.Optional[typing.List[typing.List[int]]] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = 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 )
对序列或序列对进行分词并为模型准备。
此方法已弃用，应使用 __call__ 代替。
UdopProcessor
class transformers.UdopProcessor
< source >( image_processor tokenizer )
参数
- image_processor (
LayoutLMv3ImageProcessor) — LayoutLMv3ImageProcessor 的一个实例。图像处理器是必需的输入。 - tokenizer (
UdopTokenizer或UdopTokenizerFast) — UdopTokenizer 或 UdopTokenizerFast 的一个实例。分词器是必需的输入。
构建一个 UDOP 处理器，它将 LayoutLMv3 图像处理器和 UDOP 分词器组合成一个单独的处理器。
UdopProcessor 提供了为模型准备数据所需的所有功能。
它首先使用 LayoutLMv3ImageProcessor 来调整大小、重新缩放和归一化文档图像，并可选地应用 OCR 以获取单词和归一化的边界框。然后将这些提供给 UdopTokenizer 或 UdopTokenizerFast，它们将单词和边界框转换为 token 级别的 input_ids、attention_mask、token_type_ids、bbox。可选地，可以提供整数 word_labels，这些标签被转换为 token 级别的 labels 用于 token 分类任务（例如 FUNSD、CORD）。
此外，它还支持将 text_target 和 text_pair_target 传递给分词器，这可以用于为语言建模任务准备标签。
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]] = None *args audio = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.udop.processing_udop.UdopProcessorKwargs] )
此方法首先将 images 参数转发给 ~UdopImageProcessor.__call__。如果 UdopImageProcessor 初始化时将 apply_ocr 设置为 True，它会将获得的单词和边界框以及附加参数传递给 __call__() 并返回输出，以及准备好的 pixel_values。如果 UdopImageProcessor 初始化时将 apply_ocr 设置为 False，它会将用户指定的单词（text/text_pair）和 boxes 以及附加参数传递给 __call__() 并返回输出，以及准备好的 pixel_values。
或者，可以传递 text_target 和 text_pair_target 来准备 UDOP 的目标。
有关更多信息，请参阅上述两种方法的文档字符串。
UdopModel
class transformers.UdopModel
< source >( config )
参数
- config (UdopConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 UDOP 编码器-解码器 Transformer，输出原始隐藏状态，顶部没有任何特定的头。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Tensor = None attention_mask: Tensor = None bbox: typing.Dict[str, typing.Any] = None pixel_values: typing.Optional[torch.Tensor] = None visual_bbox: typing.Dict[str, typing.Any] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None use_cache = True output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。UDOP 是一个具有相对位置嵌入的模型，因此您应该能够在左右两侧填充输入。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length), 可选) — 掩码，以避免在填充 token 索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。什么是注意力掩码？
- bbox (
torch.LongTensor，形状为({0}, 4), 可选) — 每个输入序列 token 的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框都应该是 (x0, y0, x1, y1) 格式的归一化版本，其中 (x0, y0) 对应于边界框左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1用于 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 文档图像批次。每个图像都分为形状为(num_channels, config.patch_size, config.patch_size)的 patch，并且 patch 的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - visual_bbox (
torch.LongTensor，形状为(batch_size, patch_sequence_length, 4), 可选) — 图像中每个 patch 的边界框。如果未提供，则在模型中创建边界框。 - decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列 token 在词汇表中的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ T5 使用pad_token_id作为decoder_input_ids生成的起始 token。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。要了解有关如何为预训练准备decoder_input_ids的更多信息，请查看 T5 训练。 - decoder_attention_mask (
torch.BoolTensor，形状为(batch_size, target_sequence_length), 可选) — 默认行为：生成一个 tensor，该 tensor 忽略decoder_input_ids中的 pad token。默认情况下，也将使用因果掩码。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使编码器中自注意力模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- decoder_head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空解码器中自注意力模块的选定注意力头的掩码。掩码值应在[0, 1]中选择：- 1 表示注意力头未被掩蔽，
- 0 表示注意力头已被掩蔽。
- cross_attn_head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空解码器中交叉注意力模块的选定注意力头的掩码。掩码值应在[0, 1]中选择：- 1 表示注意力头未被掩蔽，
- 0 表示注意力头已被掩蔽。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state,optional: hidden_states,optional: attentions) 组成。last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，是编码器最后一层的输出隐藏状态序列。用于解码器的交叉注意力中。 - past_key_values (
tuple(tuple(torch.FloatTensor))，长度为config.n_layers，其中每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量) — 包含注意力模块的预计算的键和值隐藏状态。可用于加速解码。如果使用了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 而不是纯元组。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列标记在序列中的位置。它用于在正确的位置更新缓存，并推断完整的序列长度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (UdopConfig) 和输入。
-
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))，可选，当传递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)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，加上可选的初始嵌入输出。
-
decoder_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.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)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
UdopModel 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, AutoModel
>>> from datasets import load_dataset
>>> import torch
>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = AutoModel.from_pretrained("microsoft/udop-large")
>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> inputs = processor(image, words, boxes=boxes, return_tensors="pt")
>>> decoder_input_ids = torch.tensor([[model.config.decoder_start_token_id]])
>>> # forward pass
>>> outputs = model(**inputs, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 1, 1024]UdopForConditionalGeneration
class transformers.UdopForConditionalGeneration
< source >( config )
参数
- config (UdopConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
具有语言建模头的 UDOP 编码器-解码器 Transformer，能够根据文档图像和可选的提示生成文本。
此类基于 T5ForConditionalGeneration，扩展为处理图像和布局 (2D) 数据。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝注意力头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Tensor = None attention_mask: Tensor = None bbox: typing.Dict[str, typing.Any] = None pixel_values: typing.Optional[torch.Tensor] = None visual_bbox: typing.Dict[str, typing.Any] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None use_cache = True output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。UDOP 是一个具有相对位置嵌入的模型，因此您应该能够在左右两侧填充输入。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 IDs？ - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值应在[0, 1]中选择：- 1 表示标记未被掩蔽，
- 0 表示标记已被掩蔽。什么是注意力掩码？
- bbox (
torch.LongTensor，形状为({0}, 4)，可选) — 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应为 (x0, y0, x1, y1) 格式的标准化版本，其中 (x0, y0) 对应于边界框中左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1用于 [CLS] 标记。有关patch_sequence_length，请参阅pixel_values。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 文档图像批次。每张图像被划分为形状为(num_channels, config.patch_size, config.patch_size)的图像块，图像块的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - visual_bbox (
torch.LongTensor，形状为(batch_size, patch_sequence_length, 4)，可选) — 图像中每个图像块的边界框。如果未提供，则在模型中创建边界框。 - decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 解码器输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ T5 使用pad_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。要了解有关如何为预训练准备decoder_input_ids的更多信息，请查看 T5 训练。 - decoder_attention_mask (
torch.BoolTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下还将使用因果掩码。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空编码器中自注意力模块的选定头的掩码。在[0, 1]中选择的掩码值：- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- decoder_head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空解码器中自注意力模块的选定头的掩码。在[0, 1]中选择的掩码值：- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- cross_attn_head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空解码器中交叉注意力模块的选定头的掩码。在[0, 1]中选择的掩码值：- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- encoder_outputs (
tuple(tuple(torch.FloatTensor)，可选) — 元组由 (last_hidden_state，optional: hidden_states，optional: attentions) 组成。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state是编码器最后一层输出端的隐藏状态序列。在解码器的交叉注意力中使用。 - past_key_values (长度为
config.n_layers的tuple(tuple(torch.FloatTensor))，其中每个元组具有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用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 而不是普通元组。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列标记在序列中的位置。它用于在正确的位置更新缓存，并推断完整序列长度。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]中。所有设置为-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 时），包括各种元素，具体取决于配置 (UdopConfig) 和输入。
-
loss (
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(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时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_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.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)，可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
transformers.UdopForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, UdopForConditionalGeneration
>>> from datasets import load_dataset
>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = UdopForConditionalGeneration.from_pretrained("microsoft/udop-large")
>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> # one can use the various task prefixes (prompts) used during pre-training
>>> # e.g. the task prefix for DocVQA is "Question answering. "
>>> question = "Question answering. What is the date on the form?"
>>> encoding = processor(image, question, text_pair=words, boxes=boxes, return_tensors="pt")
>>> # autoregressive generation
>>> predicted_ids = model.generate(**encoding)
>>> print(processor.batch_decode(predicted_ids, skip_special_tokens=True)[0])
9/30/92UdopEncoderModel
class transformers.UdopEncoderModel
< source >( config: UdopConfig )
参数
- config (UdopConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 UDOP 模型 Transformer，输出编码器的原始隐藏状态，顶部没有任何特定的头部。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Tensor = None bbox: typing.Dict[str, typing.Any] = None attention_mask: Tensor = None pixel_values: typing.Optional[torch.Tensor] = None visual_bbox: typing.Dict[str, typing.Any] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.udop.modeling_udop.BaseModelOutputWithAttentionMask 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。T5 是一个具有相对位置嵌入的模型，因此您应该能够在右侧和左侧填充输入。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解有关如何为预训练准备
input_ids的更多信息，请查看 T5 训练。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。在[0, 1]中选择的掩码值：- 1 表示标记未被掩蔽，
- 0 表示标记被掩蔽。
- bbox (
torch.LongTensor，形状为({0}, 4)，可选) — 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框都应该是 (x0, y0, x1, y1) 格式的标准化版本，其中 (x0, y0) 对应于边界框左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1用于 [CLS] 标记。有关patch_sequence_length，请参阅pixel_values。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 文档图像批次。每张图像被划分为形状为(num_channels, config.patch_size, config.patch_size)的图像块，图像块的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - visual_bbox (
torch.LongTensor，形状为(batch_size, patch_sequence_length, 4)，可选) — 图像中每个patch的边界框。如果未提供，则在模型中创建边界框。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空自注意力模块中选定head的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.udop.modeling_udop.BaseModelOutputWithAttentionMask 或 tuple(torch.FloatTensor)
一个 transformers.models.udop.modeling_udop.BaseModelOutputWithAttentionMask 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (UdopConfig) 和输入。
- 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))，可选，当传递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输入）加速顺序解码。 - 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 之后，用于计算交叉注意力头中的加权平均值。
UdopEncoderModel forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoProcessor, UdopEncoderModel
>>> from huggingface_hub import hf_hub_download
>>> from datasets import load_dataset
>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = UdopEncoderModel.from_pretrained("microsoft/udop-large")
>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")
>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state