Transformers 文档

Donut

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch

Donut

Donut (文档理解 Transformer) 是一种视觉文档理解模型,它不需要光学字符识别 (OCR) 引擎。与传统方法先使用 OCR 提取文本再处理不同,Donut 采用端到端的基于 Transformer 的架构直接分析文档图像。这消除了与 OCR 相关的低效率,使其在处理不同语言和格式方面更加准确和适应性更强。

Donut 包含视觉编码器 (Swin) 和文本解码器 (BART)。Swin 将文档图像转换为嵌入,BART 将其处理为有意义的文本序列。

您可以在 Naver Clova Information Extraction 组织下找到所有原始的 Donut 检查点。

点击右侧边栏中的 Donut 模型,了解更多如何将 Donut 应用于不同语言和视觉任务的示例。

以下示例演示了如何使用 Donut 通过 PipelineAutoModel 执行文档理解任务。

流水线
自动模型
# pip install datasets
import torch
from transformers import pipeline
from PIL import Image

pipeline = pipeline(
    task="document-question-answering",
    model="naver-clova-ix/donut-base-finetuned-docvqa",
    device=0,
    torch_dtype=torch.float16
)
dataset = load_dataset("hf-internal-testing/example-documents", split="test")
image = dataset[0]["image"]

pipeline(image=image, question="What time is the coffee break?")

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端,请参阅量化概述。

以下示例使用torchao仅将权重量化为int4。

# pip install datasets torchao
import torch
from datasets import load_dataset
from transformers import TorchAoConfig, AutoProcessor, AutoModelForVision2Seq

quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
processor = AutoProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")
model = AutoModelForVision2Seq.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa", quantization_config=quantization_config)

dataset = load_dataset("hf-internal-testing/example-documents", split="test")
image = dataset[0]["image"]
question = "What time is the coffee break?"
task_prompt = f"<s_docvqa><s_question>{question}</s_question><s_answer>"
inputs = processor(image, task_prompt, return_tensors="pt")

outputs = model.generate(
    input_ids=inputs.input_ids,
    pixel_values=inputs.pixel_values,
    max_length=512
)
answer = processor.decode(outputs[0], skip_special_tokens=True)
print(answer)

注意事项

  • 如下所示,使用 Donut 进行文档图像分类。

    >>> 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)  # doctest: +IGNORE_RESULT
    
    >>> # 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'}
  • 如下所示,使用 Donut 进行文档解析。

    >>> 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)  # doctest: +IGNORE_RESULT
    
    >>> # 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'}}

DonutSwinConfig

class 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 (strfunction, 可选, 默认为 "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.config

DonutImageProcessor

class transformers.DonutImageProcessor

< >

( do_resize: bool = True size: typing.Optional[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, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像的 (height, width) 维度调整到指定的 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 (intfloat, 可选, 默认为 1/255) — 如果重新缩放图像,使用的缩放因子。可在 preprocess 方法中通过 rescale_factor 覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可在 preprocess 方法中通过 do_normalize 覆盖。
  • image_mean (floatlist[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果归一化图像,使用的均值。这是一个浮点数或浮点数列表,其长度与图像中的通道数相同。可在 preprocess 方法中通过 image_mean 参数覆盖。
  • image_std (floatlist[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 图像标准差。

构造 Donut 图像处理器。

预处理

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None resample: Resampling = None do_thumbnail: typing.Optional[bool] = None do_align_long_axis: typing.Optional[bool] = None do_pad: typing.Optional[bool] = None random_padding: bool = False do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, 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[str, transformers.image_utils.ChannelDimension, 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 (floatlist[float], 可选, 默认为 self.image_mean) — 用于标准化的图像均值。
  • image_std (floatlist[float], 可选, 默认为 self.image_std) — 用于标准化的图像标准差。
  • return_tensors (strTensorType, 可选) — 返回张量的类型。可以是以下之一:
    • 未设置: 返回 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 (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • 未设置: 默认为输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE: 图像格式为 (height, width)。

预处理一张或一批图像。

DonutImageProcessorFast

class transformers.DonutImageProcessorFast

< >

( **kwargs: typing_extensions.Unpack[transformers.models.donut.image_processing_donut_fast.DonutFastImageProcessorKwargs] )

构造一个快速的 Donut 图像处理器。

预处理

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] **kwargs: typing_extensions.Unpack[transformers.models.donut.image_processing_donut_fast.DonutFastImageProcessorKwargs] ) <class 'transformers.image_processing_base.BatchFeature'>

参数

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]) — 要预处理的图像。期望单个或批量图像,像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间,请设置 do_rescale=False
  • do_resize (bool, 可选) — 是否调整图像大小。
  • size (dict[str, int], 可选) — 描述模型的最大输入尺寸。
  • default_to_square (bool, 可选) — 如果尺寸为整数,是否默认调整为方形图像。
  • resample (Union[PILImageResampling, F.InterpolationMode, NoneType]) — 如果调整图像大小,使用的重采样滤波器。可以是枚举 PILImageResampling 之一。仅当 do_resize 设置为 True 时有效。
  • do_center_crop (bool, 可选) — 是否中心裁剪图像。
  • crop_size (dict[str, int], 可选) — 应用 center_crop 后输出图像的大小。
  • do_rescale (bool, 可选) — 是否重新缩放图像。
  • rescale_factor (Union[int, float, NoneType]) — 如果 do_rescale 设置为 True,则用于重新缩放图像的缩放因子。
  • do_normalize (bool, 可选) — 是否标准化图像。
  • image_mean (Union[float, list[float], NoneType]) — 用于标准化的图像均值。仅当 do_normalize 设置为 True 时有效。
  • image_std (Union[float, list[float], NoneType]) — 用于标准化的图像标准差。仅当 do_normalize 设置为 True 时有效。
  • do_convert_rgb (bool, 可选) — 是否将图像转换为 RGB。
  • return_tensors (Union[str, ~utils.generic.TensorType, NoneType]) — 如果设置为 `pt` 则返回堆叠的张量,否则返回张量列表。
  • data_format (~image_utils.ChannelDimension, 可选) — 输出图像的通道维度格式。仅支持 ChannelDimension.FIRST。为兼容慢速处理器而添加。
  • input_data_format (Union[str, ~image_utils.ChannelDimension, NoneType]) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE: 图像格式为 (height, width)。
  • device (torch.device, 可选) — 处理图像的设备。如果未设置,则从输入图像推断设备。
  • disable_grouping (bool, 可选) — 是否禁用图像按大小分组以单独处理而不是批量处理。如果为 None,则如果图像在 CPU 上,则设置为 True,否则设置为 False。此选择基于经验观察,详情请参阅:https://github.com/huggingface/transformers/pull/38157
  • 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,则每个图像的每个边将随机填充,直到达到批次中最大图像的大小。否则,所有图像将填充到批次中最大图像的大小。

返回

<class 'transformers.image_processing_base.BatchFeature'>

  • data (dict) — 由 call 方法返回的列表/数组/张量字典(“pixel_values”等)。
  • tensor_type (Union[None, str, TensorType], 可选) — 您可以在此处提供一个`tensor_type`,以便在初始化时将整数列表转换为PyTorch/TensorFlow/Numpy张量。

DonutFeatureExtractor

class transformers.DonutFeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

预处理单张或批量图像。

DonutProcessor

class transformers.DonutProcessor

< >

( 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__

< >

( 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, 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

< >

( 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 (stros.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

< >

( save_directory push_to_hub: bool = False **kwargs )

参数

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

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

此类方法仅调用 `save_pretrained()``save_pretrained()`。有关更多信息,请参阅上述方法的文档字符串。

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

DonutSwinModel

class transformers.DonutSwinModel

< >

( config add_pooling_layer = True use_mask_token = False )

参数

  • config (DonutSwinModel) — 模型的配置类,包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重,只加载配置。请查看 `from_pretrained()` 方法以加载模型权重。
  • add_pooling_layer (bool, optional, 默认为 True) — 是否添加一个池化层
  • use_mask_token (bool, optional, 默认为 False) — 是否将掩码标记用于掩码图像建模。

裸 Donut Swin 模型,输出原始隐藏状态,顶部没有任何特定头部。

此模型继承自 `PreTrainedModel`。有关库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等),请查看超类文档。

此模型也是 PyTorch `torch.nn.Module` 的子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( 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.DonutSwinModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, image_size, image_size)可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息,请参见 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • bool_masked_pos (torch.BoolTensor,形状为 (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被掩码 (1),哪些未被掩码 (0)。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码
    • 0 表示头部已被掩码
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • interpolate_pos_encoding (bool, 默认为 False) — 是否对预训练的位置编码进行插值。
  • return_dict (bool, 可选) — 是否返回 `ModelOutput` 而不是普通元组。

返回

transformers.models.donut.modeling_donut_swin.DonutSwinModelOutputtuple(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, 可选,默认为 None) — 模型最后一层输出的隐藏状态序列。

  • 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` 实例,因为前者负责运行预处理和后处理步骤,而后者会默默忽略它们。

DonutSwinForImageClassification

class transformers.DonutSwinForImageClassification

< >

( config )

参数

DonutSwin 模型转换器,顶部带有一个图像分类头([CLS] 标记最终隐藏状态顶部的线性层),例如用于 ImageNet。

请注意,通过在模型的 `forward` 中将 `interpolate_pos_encoding` 设置为 `True`,可以在比其训练图像更高分辨率的图像上微调 DonutSwin。这将把预训练的位置嵌入插值到更高分辨率。

此模型继承自 `PreTrainedModel`。有关库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等),请查看超类文档。

此模型也是 PyTorch `torch.nn.Module` 的子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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.DonutSwinImageClassifierOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, image_size, image_size)可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息,请参见 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码
    • 0 表示头部已被掩码
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 之间。如果 config.num_labels == 1,则计算回归损失(均方损失);如果 config.num_labels > 1,则计算分类损失(交叉熵)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • interpolate_pos_encoding (bool, 默认为 False) — 是否对预训练的位置编码进行插值。
  • return_dict (bool, 可选) — 是否返回 `ModelOutput` 而不是普通元组。

返回

transformers.models.donut.modeling_donut_swin.DonutSwinImageClassifierOutputtuple(torch.FloatTensor)

一个 transformers.models.donut.modeling_donut_swin.DonutSwinImageClassifierOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置 (`DonutSwinConfig`) 和输入包含各种元素。

  • loss (形状为 (1,)torch.FloatTensor可选,当提供 labels 时返回) — 分类损失(如果 config.num_labels==1,则为回归损失)。

  • logits (形状为 (batch_size, config.num_labels)torch.FloatTensor) — 分类(如果 config.num_labels==1,则为回归)分数(SoftMax 之前)。

  • 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)

    模型在每层输出处的隐藏状态,以及重新调整以包含空间维度的初始嵌入输出。

此 `transformers.models.donut.modeling_donut_swin.DonutSwinForImageClassification` 的 `forward` 方法,覆盖了 `__call__` 特殊方法。

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

示例

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("naver-clova-ix/donut-base")
>>> model = DonutSwinForImageClassification.from_pretrained("naver-clova-ix/donut-base")

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

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...
< > 在 GitHub 上更新