Donut

概述

Donut 模型在 OCR-free Document Understanding Transformer 中提出，作者是 Geewook Kim, Teakgyu Hong, Moonbin Yim, Jeongyeon Nam, Jinyoung Park, Jinyeong Yim, Wonseok Hwang, Sangdoo Yun, Dongyoon Han, Seunghyun Park。Donut 由图像 Transformer 编码器和自回归文本 Transformer 解码器组成，用于执行文档理解任务，例如文档图像分类、表单理解和视觉问答。

论文摘要如下

理解文档图像（例如，发票）是一项核心但具有挑战性的任务，因为它需要复杂的功能，例如阅读文本和对文档的整体理解。当前的视觉文档理解 (VDU) 方法将文本阅读任务外包给现成的光学字符识别 (OCR) 引擎，并专注于使用 OCR 输出的理解任务。尽管这种基于 OCR 的方法已经显示出令人鼓舞的性能，但它们存在以下问题：1) 使用 OCR 的计算成本高；2) OCR 模型在语言或文档类型上的不灵活性；3) OCR 错误传播到后续过程。为了解决这些问题，在本文中，我们介绍了一种名为 Donut 的新型无 OCR 的 VDU 模型，它代表文档理解 Transformer。作为无 OCR VDU 研究的第一步，我们提出了一个简单的架构（即 Transformer），并具有预训练目标（即交叉熵损失）。Donut 在概念上简单但有效。通过广泛的实验和分析，我们展示了一个简单的无 OCR VDU 模型 Donut，在速度和准确性方面，在各种 VDU 任务上都实现了最先进的性能。此外，我们提供了一个合成数据生成器，可以帮助模型预训练在各种语言和领域中具有灵活性。

Donut 高级概述。摘自原始论文。

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

使用技巧

开始使用 Donut 的最快方法是查看教程笔记本，其中展示了如何在推理时使用模型以及在自定义数据上进行微调。
Donut 始终在 VisionEncoderDecoder 框架内使用。

推理示例

Donut 的 VisionEncoderDecoder 模型接受图像作为输入，并使用 generate() 来自回归地生成给定输入图像的文本。

DonutImageProcessor 类负责预处理输入图像，而 [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 将生成的target tokens解码为目标字符串。DonutProcessor 将 DonutImageProcessor 和 [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 包装到单个实例中，以同时提取输入特征和解码预测的 token id。

逐步文档图像分类

>>> import re

>>> from transformers import DonutProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch

>>> processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-rvlcdip")
>>> model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-rvlcdip")

>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # load document image
>>> dataset = load_dataset("hf-internal-testing/example-documents", split="test")
>>> image = dataset[1]["image"]

>>> # prepare decoder inputs
>>> task_prompt = "<s_rvlcdip>"
>>> decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids

>>> pixel_values = processor(image, return_tensors="pt").pixel_values

>>> outputs = model.generate(
...     pixel_values.to(device),
...     decoder_input_ids=decoder_input_ids.to(device),
...     max_length=model.decoder.config.max_position_embeddings,
...     pad_token_id=processor.tokenizer.pad_token_id,
...     eos_token_id=processor.tokenizer.eos_token_id,
...     use_cache=True,
...     bad_words_ids=[[processor.tokenizer.unk_token_id]],
...     return_dict_in_generate=True,
... )

>>> sequence = processor.batch_decode(outputs.sequences)[0]
>>> sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
>>> sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
>>> print(processor.token2json(sequence))
{'class': 'advertisement'}

逐步文档解析

>>> import re

>>> from transformers import DonutProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch

>>> processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")
>>> model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")

>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # load document image
>>> dataset = load_dataset("hf-internal-testing/example-documents", split="test")
>>> image = dataset[2]["image"]

>>> # prepare decoder inputs
>>> task_prompt = "<s_cord-v2>"
>>> decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids

>>> pixel_values = processor(image, return_tensors="pt").pixel_values

>>> outputs = model.generate(
...     pixel_values.to(device),
...     decoder_input_ids=decoder_input_ids.to(device),
...     max_length=model.decoder.config.max_position_embeddings,
...     pad_token_id=processor.tokenizer.pad_token_id,
...     eos_token_id=processor.tokenizer.eos_token_id,
...     use_cache=True,
...     bad_words_ids=[[processor.tokenizer.unk_token_id]],
...     return_dict_in_generate=True,
... )

>>> sequence = processor.batch_decode(outputs.sequences)[0]
>>> sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
>>> sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
>>> print(processor.token2json(sequence))
{'menu': {'nm': 'CINNAMON SUGAR', 'unitprice': '17,000', 'cnt': '1 x', 'price': '17,000'}, 'sub_total': {'subtotal_price': '17,000'}, 'total': {'total_price': '17,000', 'cashprice': '20,000', 'changeprice': '3,000'}}

逐步文档视觉问答 (DocVQA)

>>> import re

>>> from transformers import DonutProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch

>>> processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")
>>> model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")

>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # load document image from the DocVQA dataset
>>> dataset = load_dataset("hf-internal-testing/example-documents", split="test")
>>> image = dataset[0]["image"]

>>> # prepare decoder inputs
>>> task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
>>> question = "When is the coffee break?"
>>> prompt = task_prompt.replace("{user_input}", question)
>>> decoder_input_ids = processor.tokenizer(prompt, add_special_tokens=False, return_tensors="pt").input_ids

>>> pixel_values = processor(image, return_tensors="pt").pixel_values

>>> outputs = model.generate(
...     pixel_values.to(device),
...     decoder_input_ids=decoder_input_ids.to(device),
...     max_length=model.decoder.config.max_position_embeddings,
...     pad_token_id=processor.tokenizer.pad_token_id,
...     eos_token_id=processor.tokenizer.eos_token_id,
...     use_cache=True,
...     bad_words_ids=[[processor.tokenizer.unk_token_id]],
...     return_dict_in_generate=True,
... )

>>> sequence = processor.batch_decode(outputs.sequences)[0]
>>> sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
>>> sequence = re.sub(r"<.*?>", "", sequence, count=1).strip()  # remove first task start token
>>> print(processor.token2json(sequence))
{'question': 'When is the coffee break?', 'answer': '11-14 to 11:39 a.m.'}

查看模型中心以查找 Donut 检查点。

训练

我们参考教程笔记本。

DonutSwinConfig

class transformers.DonutSwinConfig

< source >

( image_size = 224 patch_size = 4 num_channels = 3 embed_dim = 96 depths = [2, 2, 6, 2] num_heads = [3, 6, 12, 24] window_size = 7 mlp_ratio = 4.0 qkv_bias = True hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 drop_path_rate = 0.1 hidden_act = 'gelu' use_absolute_embeddings = False initializer_range = 0.02 layer_norm_eps = 1e-05 **kwargs )

参数

image_size (int, 可选, 默认为 224) — 每个图像的大小（分辨率）。
patch_size (int, 可选, 默认为 4) — 每个图像块的大小（分辨率）。
num_channels (int, 可选, 默认为 3) — 输入通道的数量。
embed_dim (int, 可选, 默认为 96) — 图像块嵌入的维度。
depths (list(int), 可选, 默认为 [2, 2, 6, 2]) — Transformer 编码器中每一层的深度。
num_heads (list(int), 可选, 默认为 [3, 6, 12, 24]) — Transformer 编码器每一层中注意力头的数量。
window_size (int, 可选, 默认为 7) — 窗口大小。
mlp_ratio (float, 可选, 默认为 4.0) — MLP 隐藏层维度与嵌入层维度的比率。
qkv_bias (bool, 可选, 默认为 True) — 是否向 queries, keys 和 values 添加可学习的偏置项。
hidden_dropout_prob (float, 可选, 默认为 0.0) — 嵌入层和编码器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
drop_path_rate (float, 可选, 默认为 0.1) — 随机深度比率。
hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu", "relu", "selu" 和 "gelu_new"。
use_absolute_embeddings (bool, 可选, 默认为 False) — 是否向图像块嵌入添加绝对位置嵌入。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-05) — layer normalization 层使用的 epsilon 值。

这是用于存储 DonutSwinModel 配置的配置类。它用于根据指定的参数实例化 Donut 模型，定义模型架构。使用默认值实例化配置将产生与 Donut naver-clova-ix/donut-base 架构类似的配置。

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

示例

>>> from transformers import DonutSwinConfig, DonutSwinModel

>>> # Initializing a Donut naver-clova-ix/donut-base style configuration
>>> configuration = DonutSwinConfig()

>>> # Randomly initializing a model from the naver-clova-ix/donut-base style configuration
>>> model = DonutSwinModel(configuration)

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

DonutImageProcessor

class transformers.DonutImageProcessor

< source >

( do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BILINEAR: 2> do_thumbnail: bool = True do_align_long_axis: bool = False do_pad: bool = True do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None **kwargs )

参数

do_resize (bool, 可选, 默认为 True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 覆盖。
size (Dict[str, int] 可选, 默认为 {"shortest_edge" -- 224}): 调整大小后的图像尺寸。图像的最短边将调整为 size[“shortest_edge”]，最长边将调整以保持输入宽高比。可以被 preprocess 方法中的 size 覆盖。
resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 如果调整图像大小，要使用的重采样滤波器。可以被 preprocess 方法中的 resample 覆盖。
do_thumbnail (bool, 可选, 默认为 True) — 是否使用缩略图方法调整图像大小。
do_align_long_axis (bool, 可选, 默认为 False) — 是否通过旋转 90 度来对齐图像的长轴与 size 的长轴。
do_pad (bool, 可选, 默认为 True) — 是否填充图像。如果在 preprocess 中将 random_padding 设置为 True，则每个图像将在每个尺寸上填充随机量的填充，最多为批次中最大的图像尺寸。否则，所有图像都将填充到批次中最大的图像尺寸。
do_rescale (bool, 可选, 默认为 True) — 是否按指定的比例 rescale_factor 缩放图像。可以被 preprocess 方法中的 do_rescale 覆盖。
rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果要缩放图像，则使用的缩放因子。可以被 preprocess 方法中的 rescale_factor 覆盖。
do_normalize (bool, 可选, 默认为 True) — 是否标准化图像。可以被 preprocess 方法中的 do_normalize 覆盖。
image_mean (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果要标准化图像，则使用的均值。这是一个浮点数或浮点数列表，其长度与图像中的通道数相同。可以被 preprocess 方法中的 image_mean 参数覆盖。
image_std (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 图像标准差。

构建 Donut 图像处理器。

preprocess

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: bool = None size: typing.Dict[str, int] = None resample: Resampling = None do_thumbnail: bool = None do_align_long_axis: bool = None do_pad: bool = None random_padding: bool = False do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None )

参数

images (ImageInput) — 要预处理的图像。接受像素值范围为 0 到 255 的单张或批量图像。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后图像的尺寸。图像的最短边将调整为 min(size[“height”], size[“width”])，最长边将调整以保持输入的长宽比。
resample (int, 可选, 默认为 self.resample) — 如果调整图像大小，则使用的重采样滤波器。这可以是枚举 PILImageResampling 之一。仅当 do_resize 设置为 True 时才有效。
do_thumbnail (bool, 可选, 默认为 self.do_thumbnail) — 是否使用缩略图方法调整图像大小。
do_align_long_axis (bool, 可选, 默认为 self.do_align_long_axis) — 是否通过旋转 90 度来对齐图像的长轴与 size 的长轴。
do_pad (bool, 可选, 默认为 self.do_pad) — 是否填充图像。如果 random_padding 设置为 True，则每个图像在每个边上填充随机量的填充，最多为批次中最大的图像尺寸。否则，所有图像都将填充到批次中最大的图像尺寸。
random_padding (bool, 可选, 默认为 self.random_padding) — 填充图像时是否使用随机填充。如果为 True，则批次中的每个图像将在每个边上填充随机量的填充，最多为批次中最大图像的尺寸。
do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像像素值。
rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的缩放因子。
do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否标准化图像。
image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 用于标准化的图像均值。
image_std (float 或 List[float], 可选, 默认为 self.image_std) — 用于标准化的图像标准差。
return_tensors (str 或 TensorType, 可选) — 返回张量的类型。可以是以下之一：
- Unset: 返回 np.ndarray 列表。
- TensorType.TENSORFLOW 或 'tf': 返回 tf.Tensor 类型的批次。
- TensorType.PYTORCH 或 'pt': 返回 torch.Tensor 类型的批次。
- TensorType.NUMPY 或 'np': 返回 np.ndarray 类型的批次。
- TensorType.JAX 或 'jax': 返回 jax.numpy.ndarray 类型的批次。
data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
- ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
- ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
- Unset: 默认为输入图像的通道维度格式。
input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则通道维度格式从输入图像推断。可以是以下之一：
- "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
- "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
- "none" 或 ChannelDimension.NONE: 图像格式为 (height, width)。

预处理单张或批量图像。

DonutFeatureExtractor

class transformers.DonutFeatureExtractor

< source >

( *args **kwargs )

call

< source >

( images **kwargs )

预处理单张图像或批量图像。

DonutProcessor

class transformers.DonutProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

image_processor (DonutImageProcessor, 可选) — DonutImageProcessor 的实例。图像处理器是必需的输入。
tokenizer ([XLMRobertaTokenizer/XLMRobertaTokenizerFast], 可选) — [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 的实例。分词器是必需的输入。

构建一个 Donut 处理器，它将 Donut 图像处理器和 XLMRoBERTa 分词器包装到单个处理器中。

DonutProcessor 提供 DonutImageProcessor 和 [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 的所有功能。有关更多信息，请参阅 call() 和 decode() 。

call

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] = None text: typing.Union[str, typing.List[str], NoneType] = None audio = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.donut.processing_donut.DonutProcessorKwargs] )

当在正常模式下使用时，此方法将其所有参数转发到 AutoImageProcessor 的 __call__() 并返回其输出。如果在 as_target_processor() 上下文中使用，则此方法将其所有参数转发到 DonutTokenizer 的 ~DonutTokenizer.__call__。有关更多信息，请参阅上述两种方法的文档字符串。

from_pretrained

< source >

( pretrained_model_name_or_path: typing.Union[str, os.PathLike] cache_dir: typing.Union[str, os.PathLike, NoneType] = None force_download: bool = False local_files_only: bool = False token: typing.Union[str, bool, NoneType] = None revision: str = 'main' **kwargs )

参数

pretrained_model_name_or_path (str 或 os.PathLike) — 可以是以下之一：
- 一个字符串，即托管在 huggingface.co 模型仓库中的预训练 feature_extractor 的模型 ID。
- 一个目录的路径，其中包含使用 save_pretrained() 方法保存的特征提取器文件，例如，./my_model_directory/。
- 一个保存的特征提取器 JSON 文件的路径或 URL，例如，./my_model_directory/preprocessor_config.json。
**kwargs — 传递给 from_pretrained() 和 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 的额外关键字参数。

实例化一个与预训练模型关联的处理器。

这个类方法只是简单地调用了特征提取器 from_pretrained()，图像处理器 ImageProcessingMixin 和分词器 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。有关更多信息，请参阅上述方法的文档字符串。

save_pretrained

< source >

( save_directory push_to_hub: bool = False **kwargs )

参数

save_directory (str 或 os.PathLike) — 将在其中保存特征提取器 JSON 文件和分词器文件的目录（如果目录不存在，则会创建目录）。
push_to_hub (bool, 可选，默认为 False) — 是否在保存模型后将其推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的仓库（默认为您命名空间中 save_directory 的名称）。
kwargs (Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的额外关键字参数。

将此处理器（特征提取器、分词器...）的属性保存在指定目录中，以便可以使用 from_pretrained() 方法重新加载。

这个类方法只是简单地调用了 save_pretrained() 和 save_pretrained()。有关更多信息，请参阅上述方法的文档字符串。

batch_decode

< source >

( *args **kwargs )

此方法将其所有参数转发到 DonutTokenizer 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。

decode

< source >

( *args **kwargs )

此方法将其所有参数转发到 DonutTokenizer 的 decode()。有关更多信息，请参阅此方法的文档字符串。

DonutSwinModel

class transformers.DonutSwinModel

< source >

( config add_pooling_layer = True use_mask_token = False )

参数

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

裸 Donut Swin 模型 Transformer 输出原始隐藏状态，顶部没有任何特定的头部。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< source >

( pixel_values: typing.Optional[torch.FloatTensor] = None bool_masked_pos: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 DonutImageProcessor.call()。
head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor, 可选) — 用于置空自注意力模块的选定头的掩码。在 [0, 1] 中选择的掩码值：
- 1 表示头是未被掩蔽的，
- 0 表示头是被掩蔽的。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
interpolate_pos_encoding (bool, 可选，默认为 False) — 是否插值预训练的位置编码。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
bool_masked_pos (形状为 (batch_size, num_patches) 的 torch.BoolTensor) — 布尔掩码位置。指示哪些补丁被掩蔽 (1) 以及哪些未被掩蔽 (0)。

返回值

transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (DonutSwinConfig) 和输入。

last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。
pooler_output (形状为 (batch_size, hidden_size) 的 torch.FloatTensor, 可选, 当传递 add_pooling_layer=True 时返回) — 最后一层隐藏状态的平均池化。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。
reshaped_hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 (batch_size, hidden_size, height, width)。

模型在每一层输出的隐藏状态加上初始嵌入输出，并重塑为包含空间维度。

DonutSwinModel forward 方法，覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, DonutSwinModel
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("https://huggingface.co/naver-clova-ix/donut-base")
>>> model = DonutSwinModel.from_pretrained("https://huggingface.co/naver-clova-ix/donut-base")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 49, 768]

< > Update on GitHub

Transformers

Donut

概述

使用技巧

推理示例

训练

DonutSwinConfig

class transformers.DonutSwinConfig

DonutImageProcessor

class transformers.DonutImageProcessor

preprocess

DonutFeatureExtractor

class transformers.DonutFeatureExtractor

__call__

DonutProcessor

class transformers.DonutProcessor

__call__

from_pretrained

save_pretrained

batch_decode

decode

DonutSwinModel

class transformers.DonutSwinModel

forward

call

call