Donut
概述
Donut 模型由 Geewook Kim、Teakgyu Hong、Moonbin Yim、Jeongyeon Nam、Jinyoung Park、Jinyeong Yim、Wonseok Hwang、Sangdoo Yun、Dongyoon Han 和 Seunghyun Park 在 《OCR-free Document Understanding Transformer》 中提出。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 高级概述。取自 原始论文。 使用技巧
- 开始使用 Donut 的最快方法是查看 教程笔记本，这些笔记本展示了如何在推理时使用模型以及如何根据自定义数据进行微调。
- Donut 始终在 VisionEncoderDecoder 框架内使用。
推理示例
Donut 的 VisionEncoderDecoder 模型接受图像作为输入，并利用 generate() 根据输入图像自回归地生成文本。
DonutImageProcessor 类负责预处理输入图像，[XLMRobertaTokenizer/XLMRobertaTokenizerFast] 将生成的目標标记解码为目標字符串。 DonutProcessor 将 DonutImageProcessor 和 [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 封装到单个实例中，以提取输入特征并解码预测的标记 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
类 transformers.DonutSwinConfig
< 源代码 >( 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) — 是否将可学习的偏差添加到查询、键和值。 - 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) — 层归一化层使用的 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.configDonutImageProcessor
class transformers.DonutImageProcessor
< source >( do_resize: bool = True size: Dict = 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: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = 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 图像处理器。
预处理
< 源代码 >（ images: Union do_resize: bool = None size: Dict = 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: Union = None image_std: Union = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = 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，可选) — 要返回的张量类型。可以是以下之一：- 未设置：返回一个
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) 格式。- 未设置：默认为输入图像的通道维度格式。
- 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
预处理一张或一批图像。
DonutProcessor
类 transformers.DonutProcessor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (DonutImageProcessor, 可选) — DonutImageProcessor 的实例。图像处理器是必填项。
- tokenizer ([
XLMRobertaTokenizer/XLMRobertaTokenizerFast], 可选) — [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 的实例。tokenizer 是必填项。
构造一个 Donut 处理器，将 Donut 图像处理器和一个 XLMRoBERTa tokenizer 包装到单个处理器中。
DonutProcessor 提供 DonutImageProcessor 和 [XLMRobertaTokenizer/XLMRobertaTokenizerFast] 的所有功能。有关更多信息，请参阅 call() 和 decode()。
在正常模式下使用时，此方法会将其所有参数转发给 AutoImageProcessor 的 __call__() 并返回其输出。如果在上下文 as_target_processor() 中使用，此方法会将其所有参数转发给 DonutTokenizer 的 ~DonutTokenizer.__call__。有关更多信息，请参阅上述两种方法的文档字符串。
from_pretrained
< source >( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )
参数
- pretrained_model_name_or_path (
str或os.PathLike) — 可以是以下任意一种:- 字符串，在 huggingface.co 上托管的模型库中预训练特征提取器的 *模型 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()。 有关更多信息，请参阅上述方法的文档字符串。
此方法将其所有参数转发给 DonutTokenizer 的 batch_decode()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发给 DonutTokenizer 的 decode()。 有关更多信息，请参阅此方法的文档字符串。
DonutSwinModel
class transformers.DonutSwinModel
< source >( config add_pooling_layer = True use_mask_token = False )
参数
- config (DonutSwinConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 查看 from_pretrained() 方法以加载模型权重。
裸 Donut Swin 模型转换器输出原始隐藏状态，顶部没有任何特定头部。 此模型是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般使用和行为的所有事项。
forward
< source >( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None interpolate_pos_encoding: bool = False return_dict: Optional = None ) → transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 DonutImageProcessor.call()。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于将自注意力模块的选定头部置零的掩码。在[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 (
torch.BoolTensor, 形状为(batch_size, num_patches)) — 布尔掩码位置。指示哪些块被掩码 (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 (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor, 形状为(batch_size, hidden_size), 可选，当传递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]