Transformers 文档

DeiT

Hugging Face's logo
加入 Hugging Face 社区

并获取增强型文档体验

开始使用

DeiT

概述

DeiT 模型由 Hugo Touvron、Matthieu Cord、Matthijs Douze、Francisco Massa、Alexandre Sablayrolles、Hervé Jégou 在Training data-efficient image transformers & distillation through attention中提出。 在Dosovitskiy et al., 2020中介绍的视觉 Transformer (ViT)表明,可以使用 Transformer 编码器(类似 BERT)来匹配甚至超越现有的卷积神经网络。 然而,该论文中介绍的 ViT 模型需要使用数周时间在昂贵的基础设施上进行训练,并使用外部数据。 DeiT(数据高效图像 Transformer)是用于图像分类的更高效训练 Transformer,与原始 ViT 模型相比,它需要的训练数据和计算资源更少。

论文中的摘要如下:

最近,纯基于注意力的神经网络被证明可以解决图像理解任务,如图像分类。 然而,这些视觉 Transformer 使用数亿张图像在昂贵的基础设施上进行预训练,从而限制了它们的应用。 在这项工作中,我们通过仅在 ImageNet 上训练,创造了一个具有竞争力的无卷积 Transformer。 我们在一个计算机上训练它们,不到 3 天时间。 我们的参考视觉 Transformer(8600 万个参数)在 ImageNet 上取得了 83.1% 的 top-1 准确率(单裁剪评估),无需任何外部数据。 更重要的是,我们引入了一种特定于 Transformer 的师生策略。 它依赖于一个蒸馏令牌,确保学生通过注意力从教师那里学习。 我们展示了这种基于令牌的蒸馏的意义,尤其是在使用卷积神经网络作为教师时。 这使我们能够在 ImageNet(我们获得了高达 85.2% 的准确率)上以及在迁移到其他任务时,获得与卷积神经网络相媲美的结果。 我们共享我们的代码和模型。

该模型由nielsr贡献。 该模型的 TensorFlow 版本由amyeroberts添加。

使用技巧

  • 与 ViT 相比,DeiT 模型使用一个名为蒸馏令牌的机制来有效地从教师那里学习(在 DeiT 论文中,教师是类似 ResNet 的模型)。 蒸馏令牌通过反向传播学习,通过自注意力层与类别 ([CLS]) 和补丁令牌进行交互。
  • 微调蒸馏模型有两种方法: (1) 以经典方式,仅将预测头放在类别令牌的最终隐藏状态之上,而不使用蒸馏信号;或者 (2) 将预测头放在类别令牌之上和蒸馏令牌之上。 在这种情况下,[CLS] 预测头使用预测头与真实标签之间的交叉熵进行训练,而蒸馏预测头使用硬蒸馏(蒸馏预测头与教师预测的标签之间的交叉熵)进行训练。 在推理时,最终预测将取两个头的平均预测。(2) 也被称为“带有蒸馏的微调”,因为这依赖于已经在下游数据集上进行微调的教师。 就模型而言,(1) 对应于DeiTForImageClassification,而 (2) 对应于DeiTForImageClassificationWithTeacher.
  • 请注意,作者也尝试过对 (2) 使用软蒸馏(在这种情况下,蒸馏预测头使用 KL 散度来匹配教师的 softmax 输出),但硬蒸馏获得了最佳结果。
  • 所有发布的检查点仅在 ImageNet-1k 上进行了预训练和微调。 没有使用任何外部数据。 这与原始 ViT 模型形成对比,后者使用外部数据(如 JFT-300M 数据集/ImageNet-21k)进行预训练。
  • DeiT 的作者还发布了训练效率更高的 ViT 模型,您可以直接将其插入ViTModelViTForImageClassification。 数据增强、优化和正则化等技术被用来模拟在更大数据集上的训练(而仅使用 ImageNet-1k 进行预训练)。 共有 4 个变体可用(3 种不同的大小):facebook/deit-tiny-patch16-224facebook/deit-small-patch16-224facebook/deit-base-patch16-224facebook/deit-base-patch16-384。 请注意,应使用DeiTImageProcessor 来为模型准备图像。

使用缩放点积注意力 (SDPA)

PyTorch 将本机缩放点积注意力 (SDPA) 运算符作为 torch.nn.functional 的一部分。 此函数包含多种实现,可以根据输入和使用的硬件进行应用。 请参阅官方文档GPU 推理 页面以了解更多信息。

对于 torch>=2.1.1,SDPA 默认情况下会被使用,但您也可以在 from_pretrained() 中设置 attn_implementation="sdpa" 来显式请求使用 SDPA。

from transformers import DeiTForImageClassification
model = DeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224", attn_implementation="sdpa", torch_dtype=torch.float16)
...

为了获得最佳加速效果,我们建议以半精度(例如 torch.float16torch.bfloat16)加载模型。

在一个本地基准测试(A100-40GB、PyTorch 2.3.0、操作系统 Ubuntu 22.04)上,使用 float32facebook/deit-base-distilled-patch16-224 模型,我们在推理过程中观察到以下加速效果。

批次大小 平均推理时间(毫秒),渴望模式 平均推理时间(毫秒),sdpa 模型 加速效果,Sdpa / 渴望 (x)
1 8 6 1.33
2 9 6 1.5
4 9 6 1.5
8 8 6 1.33

资源

以下是一些官方 Hugging Face 和社区 (🌎 表示) 资源列表,可帮助您开始使用 DeiT。

图像分类

除此之外

如果您有兴趣提交要包含在此处的资源,请随时打开 Pull Request,我们将进行审核! 资源理想情况下应该展示一些新内容,而不是重复现有的资源。

DeiTConfig

class transformers.DeiTConfig

< >

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 224 patch_size = 16 num_channels = 3 qkv_bias = True encoder_stride = 16 **kwargs )

参数

  • hidden_size (int, 可选, 默认值为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, 可选, 默认值为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认值为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • intermediate_size (int, 可选, 默认值为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • hidden_act (strfunction, 可选, 默认值为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。 如果是字符串,则支持 "gelu""relu""selu""gelu_new"
  • hidden_dropout_prob (float, 可选, 默认值为 0.0) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
  • attention_probs_dropout_prob (float, 可选, 默认值为 0.0) — 注意力概率的丢弃率。
  • initializer_range (float, 可选, 默认值为 0.02) — 初始化所有权重矩阵的截断正态初始化的标准差。
  • layer_norm_eps (float, 可选, 默认值为 1e-12) — 层归一化层使用的 epsilon。
  • patch_size (int, 可选, 默认值为 16) — 每个补丁的大小(分辨率)。
  • num_channels (int, 可选, 默认值为 3) — 输入通道的数量。
  • qkv_bias (bool, 可选, 默认值为 True) — 是否向查询、键和值添加偏置。
  • encoder_stride (int, 可选, 默认值为 16) — 在解码器头部为掩码图像建模增加空间分辨率的因子。

这是用于存储 DeiTModel 配置的配置类。 它用于根据指定的参数实例化 DeiT 模型,定义模型架构。 使用默认值实例化配置将产生与 DeiT facebook/deit-base-distilled-patch16-224 架构类似的配置。

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

示例

>>> from transformers import DeiTConfig, DeiTModel

>>> # Initializing a DeiT deit-base-distilled-patch16-224 style configuration
>>> configuration = DeiTConfig()

>>> # Initializing a model (with random weights) from the deit-base-distilled-patch16-224 style configuration
>>> model = DeiTModel(configuration)

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

DeiTFeatureExtractor

transformers.DeiTFeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

预处理图像或一批图像。

DeiTImageProcessor

transformers.DeiTImageProcessor

< >

( do_resize: bool = True size: Dict = None resample: Resampling = 3 do_center_crop: bool = True crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 do_rescale: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None

参数

  • do_resize (bool, 可选, 默认为 True) — 是否将图像的 (高度, 宽度) 尺寸调整为指定的 size。可以通过 preprocess 中的 do_resize 覆盖。
  • size (Dict[str, int] 可选, 默认为 {"height" -- 256, "width": 256}): resize 之后图像的大小。可以通过 preprocess 中的 size 覆盖。
  • resample (PILImageResampling 过滤器, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小,要使用的重采样过滤器。可以通过 preprocess 中的 resample 覆盖。
  • do_center_crop (bool, 可选, 默认为 True) — 是否中心裁剪图像。如果输入大小在任何边缘都小于 crop_size,则用 0 填充图像,然后进行中心裁剪。可以通过 preprocess 中的 do_center_crop 覆盖。
  • crop_size (Dict[str, int], 可选, 默认为 {"height" -- 224, "width": 224}): 应用中心裁剪时的目标输出大小。可以通过 preprocess 中的 crop_size 覆盖。
  • rescale_factor (intfloat, 可选, 默认为 1/255) — 如果重新缩放图像,要使用的缩放因子。可以通过 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否按指定的比例 rescale_factor 重新缩放图像。可以通过 preprocess 方法中的 do_rescale 参数覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否标准化图像。可以通过 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (floatList[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果标准化图像,要使用的均值。这是一个浮点数或浮点数列表,长度与图像通道数相同。可以通过 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (floatList[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果标准化图像,要使用的标准差。这是一个浮点数或浮点数列表,长度与图像通道数相同。可以通过 preprocess 方法中的 image_std 参数覆盖。

构造 DeiT 图像处理器。

preprocess

< >

( images: Union do_resize: bool = None size: Dict = None resample = None do_center_crop: bool = None crop_size: Dict = None 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: ChannelDimension = <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) — resize 后图像的大小。
  • resample (PILImageResampling, 可选, 默认值为 self.resample) — 如果调整图像大小,则要使用的 PILImageResampling 过滤器。仅当 do_resize 设置为 True 时才有效。
  • do_center_crop (bool, 可选, 默认值为 self.do_center_crop) — 是否对图像进行中心裁剪。
  • crop_size (Dict[str, int], 可选, 默认值为 self.crop_size) — 中心裁剪后图像的大小。如果图像的一条边小于 crop_size,它将用零填充,然后裁剪
  • do_rescale (bool, 可选, 默认值为 self.do_rescale) — 是否将图像值缩放到 [0 - 1] 之间。
  • rescale_factor (float, 可选, 默认值为 self.rescale_factor) — 如果 do_rescale 设置为 True,则用于重新缩放图像的缩放因子。
  • image_mean (floatList[float], 可选, 默认值为 self.image_mean) — 图像均值。
  • image_std (floatList[float], 可选, 默认值为 self.image_std) — 图像标准差。
  • return_tensors (strTensorType, 可选) — 要返回的张量类型。 可以是以下之一:
    • None: 返回一个 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: 图像以 (通道数, 高度, 宽度) 格式。
    • ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。 如果未设置,则从输入图像推断通道维度格式。 可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。
    • "channels_last"ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。
    • "none"ChannelDimension.NONE: 图像以 (高度, 宽度) 格式。

预处理图像或图像批次。

Pytorch
隐藏 Pytorch 内容

DeiTModel

class transformers.DeiTModel

< >

( config: DeiTConfig add_pooling_layer: bool = True use_mask_token: bool = False )

参数

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

基础 DeiT 模型变压器,输出原始隐藏状态,没有任何特定头部。 此模型是一个 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参考 PyTorch 文档了解与一般用法和行为相关的所有事宜。

forward

< >

( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DeiTImageProcessor.call()
  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值:

    • 1 表示头部未被掩盖
    • 0 表示头部被掩盖
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  • interpolate_pos_encoding (bool, optional, defaults to False) — 是否插值预训练的位置编码。
  • bool_masked_pos (torch.BoolTensor of shape (batch_size, num_patches), optional) — 布尔掩码位置。指示哪些补丁被掩码(1)以及哪些没有(0)。

返回

transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组(如果传递了return_dict=False,或者当config.return_dict=False 时),包含取决于配置 (DeiTConfig) 和输入的各种元素。

  • last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。

  • pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 经过用于辅助预训练任务的层的进一步处理后,序列第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层权重在预训练期间从下一个句子预测(分类)目标中训练。

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor 元组(一个用于嵌入层的输出,如果模型有嵌入层,加上每个层的输出)形状 (batch_size, sequence_length, hidden_size)

    模型在每层输出处的隐藏状态,加上可选的初始嵌入输出。

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

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

The DeiTModel 正向方法,覆盖了__call__特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, DeiTModel
>>> 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("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTModel.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> 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, 198, 768]

DeiTForMaskedImageModeling

class transformers.DeiTForMaskedImageModeling

< >

( config: DeiTConfig )

参数

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

DeiT 模型,在顶部有一个用于掩码图像建模的解码器,如 SimMIM 中所述。

请注意,我们在 示例目录 中提供了一个脚本,用于在自定义数据上预训练此模型。

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

forward

< >

( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.MaskedImageModelingOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。 像素值可以使用 AutoImageProcessor 获取。 查看 DeiTImageProcessor.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 以了解更多详细信息。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。
  • interpolate_pos_encoding (bool可选,默认值为 False) — 是否插值预训练的位置编码。
  • bool_masked_pos (torch.BoolTensor 形状为 (batch_size, num_patches)) — 布尔型遮蔽位置。指示哪些补丁被遮蔽 (1) 以及哪些没有 (0)。

返回

transformers.modeling_outputs.MaskedImageModelingOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedImageModelingOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者 config.return_dict=False),其中包含各种元素,具体取决于配置 (DeiTConfig) 和输入。

  • loss (torch.FloatTensor 形状为 (1,)可选,在提供 bool_masked_pos 时返回) — 重构损失。
  • reconstruction (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 重构/完成的图像。
  • 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, patch_size, sequence_length)。自注意力头中计算加权平均值所使用的注意力 softmax 之后的权重。

DeiTForMaskedImageModeling 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, DeiTForMaskedImageModeling
>>> import torch
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]

DeiTForImageClassification

class transformers.DeiTForImageClassification

< >

( config: DeiTConfig )

参数

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

具有图像分类头的 DeiT 模型转换器(在 [CLS] 令牌的最终隐藏状态之上有一个线性层),例如用于 ImageNet。

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

forward

< >

( pixel_values: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.ImageClassifierOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。查看 DeiTImageProcessor.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
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  • interpolate_pos_encoding (bool, 可选,默认值为 False) — 是否对预训练的位置编码进行插值。
  • labels (torch.LongTensor 形状为 (batch_size,)可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.ImageClassifierOutputtuple(torch.FloatTensor)

A transformers.modeling_outputs.ImageClassifierOutputtorch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置(DeiTConfig)和输入的不同元素。

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

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

  • hidden_states (tuple(torch.FloatTensor)可选,在传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 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, patch_size, sequence_length)

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

The DeiTForImageClassification forward method, overrides the __call__ special method.

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

示例

>>> from transformers import AutoImageProcessor, DeiTForImageClassification
>>> import torch
>>> from PIL import Image
>>> import requests

>>> torch.manual_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # note: we are loading a DeiTForImageClassificationWithTeacher from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: Polaroid camera, Polaroid Land camera

DeiTForImageClassificationWithTeacher

class transformers.DeiTForImageClassificationWithTeacher

< >

( config: DeiTConfig )

参数

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

DeiT 模型转换器,顶部带有图像分类头(最终隐藏状态的 [CLS] 符号上的线性层,以及蒸馏符号的最终隐藏状态上的线性层),例如 ImageNet。

.. warning:

该模型仅支持推理。尚不支持使用蒸馏(即使用教师)进行微调。

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

forward

< >

( pixel_values: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参见 DeiTImageProcessor.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
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。
  • interpolate_pos_encoding (bool可选,默认值为 False) — 是否对预训练的位置编码进行插值。

返回

transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutputtuple(torch.FloatTensor)

A transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutputtorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置的各种元素 (DeiTConfig) 和输入。

  • logits (torch.FloatTensor 形状为 (batch_size, config.num_labels)) — 预测分数,作为 cls_logits 和蒸馏 logits 的平均值。
  • cls_logits (torch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类头的预测分数(即在类令牌的最终隐藏状态之上进行线性层)。
  • distillation_logits (torch.FloatTensor 形状为 (batch_size, config.num_labels)) — 蒸馏头的预测分数(即在蒸馏令牌的最终隐藏状态之上进行线性层)。
  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

DeiTForImageClassificationWithTeacher 正向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, DeiTForImageClassificationWithTeacher
>>> 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("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> 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])
tabby, tabby cat
TensorFlow
隐藏 TensorFlow 内容

TFDeiTModel

class transformers.TFDeiTModel

< >

( config: DeiTConfig add_pooling_layer: bool = True use_mask_token: bool = False **kwargs )

参数

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

DeiT 模型的裸 Transformer,输出原始隐藏状态,没有任何特定的头部。此模型是一个 TensorFlow keras.layers.Layer。将其用作常规的 TensorFlow 模块,并参考 TensorFlow 文档以了解所有与常规使用和行为相关的问题。

call

< >

( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None interpolate_pos_encoding: bool = False training: bool = False ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参见 DeiTImageProcessor.call()
  • head_mask (tf.Tensor 形状为 (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) — 是否插值预训练的 position 编码。
  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 tf.Tensor 元组(如果传递了 return_dict=Falseconfig.return_dict=False 时),包含取决于配置 (DeiTConfig) 和输入的各种元素。

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

  • pooler_output (tf.Tensor 形状为 (batch_size, hidden_size)) — 序列第一个 token(分类 token)的最后一层隐藏状态,由线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间从下一个句子预测(分类)目标中训练。

    此输出通常不是输入语义内容的良好摘要,您通常可以通过对整个输入序列的隐藏状态序列进行平均或池化来获得更好的结果。

  • hidden_states (tuple(tf.Tensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    每一层输出的模型隐藏状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFDeiTModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFDeiTModel
>>> 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("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTModel.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="tf")
>>> outputs = model(**inputs)

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

TFDeiTForMaskedImageModeling

class transformers.TFDeiTForMaskedImageModeling

< >

( config: DeiTConfig )

参数

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

DeiT 模型,顶部带有一个解码器用于掩码图像建模,如 SimMIM 中所提出的。此模型是一个 TensorFlow keras.layers.Layer。将其用作常规 TensorFlow 模块,并参考 TensorFlow 文档了解所有与一般用法和行为相关的事项。

call

< >

( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None interpolate_pos_encoding: bool = False training: bool = False ) transformers.modeling_tf_outputs.TFMaskedImageModelingOutput or tuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参见 DeiTImageProcessor.call()
  • head_mask (tf.Tensor 形状为 (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 (tf.Tensor 类型,形状为 (batch_size, num_patches)) — 布尔型掩码位置。指示哪些块被掩码 (1) 以及哪些没有 (0)。

返回

transformers.modeling_tf_outputs.TFMaskedImageModelingOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedImageModelingOutput 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (DeiTConfig) 和输入的不同元素。

  • loss (tf.Tensor 形状为 (1,)可选,在提供 bool_masked_pos 时返回) — 重构损失。
  • reconstruction (tf.Tensor 形状为 (batch_size, num_channels, height, width)) — 重构/完成的图像。
  • hidden_states (tuple(tf.Tensor)可选,在传递 output_hidden_states=True 或当
  • config.output_hidden_states=True): tf.Tensor 元组 (一个用于嵌入的输出,如果模型具有嵌入层,+ 一个用于每个阶段的输出) 形状为 (batch_size, sequence_length, hidden_size)。模型在每个阶段输出处的隐藏状态 (也称为特征图)。
  • attentions (tuple(tf.Tensor)可选,在传递 output_attentions=True 或当
  • config.output_attentions=True): tf.Tensor 元组 (每层一个) 形状为 (batch_size, num_heads, patch_size, sequence_length)。注意力softmax后的注意力权重,用于计算自注意力头中的加权平均值。

The TFDeiTForMaskedImageModeling 正向方法,重写了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFDeiTForMaskedImageModeling
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="tf").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = tf.cast(tf.random.uniform((1, num_patches), minval=0, maxval=2, dtype=tf.int32), tf.bool)

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]

TFDeiTForImageClassification

class transformers.TFDeiTForImageClassification

< >

( config: DeiTConfig )

参数

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

具有图像分类头的 DeiT 模型转换器(在 [CLS] 令牌的最终隐藏状态之上有一个线性层),例如用于 ImageNet。

此模型是一个 TensorFlow keras.layers.Layer。将其用作常规 TensorFlow 模块,并参考 TensorFlow 文档了解有关一般用法和行为的所有事项。

call

< >

( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None labels: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None interpolate_pos_encoding: bool = False training: bool = False ) transformers.modeling_tf_outputs.TFImageClassifierOutputtuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor 形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。查看 DeiTImageProcessor.call() 了解详情。
  • head_mask (tf.Tensor 形状为 (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 而不是普通元组。
  • labels (tf.Tensor 形状为 (batch_size,), 可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_tf_outputs.TFImageClassifierOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFImageClassifierOutput 或一个 tf.Tensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (DeiTConfig) 和输入的各种元素。

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

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

  • hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出,如果模型具有嵌入层,+ 一个用于每个阶段的输出),形状为 (batch_size, sequence_length, hidden_size)。模型在每个阶段输出处的隐藏状态(也称为特征图)。

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

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

The TFDeiTForImageClassification 正向方法,覆盖 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFDeiTForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests

>>> keras.utils.set_random_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # note: we are loading a TFDeiTForImageClassificationWithTeacher from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])
Predicted class: little blue heron, Egretta caerulea

TFDeiTForImageClassificationWithTeacher

class transformers.TFDeiTForImageClassificationWithTeacher

< >

( config: DeiTConfig )

参数

  • config (DeiTConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。

DeiT 模型转换器,顶部带有图像分类头(最终隐藏状态的 [CLS] 符号上的线性层,以及蒸馏符号的最终隐藏状态上的线性层),例如 ImageNet。

.. warning:

该模型仅支持推理。尚不支持使用蒸馏(即使用教师)进行微调。

此模型是一个 TensorFlow keras.layers.Layer。将其用作常规 TensorFlow 模块,并参考 TensorFlow 文档了解有关一般用法和行为的所有事项。

call

< >

( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None interpolate_pos_encoding: bool = False training: bool = False ) transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutputtuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor 形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参见 DeiTImageProcessor.call()
  • head_mask (tf.Tensor 形状为 (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 而不是普通元组。

返回

transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutputtuple(tf.Tensor)

一个 transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutputtf.Tensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),包含根据配置(DeiTConfig)和输入而变化的各种元素。

  • logits (tf.Tensor 形状为 (batch_size, config.num_labels)) — 预测分数,作为 cls_logits 和蒸馏 logits 的平均值。
  • cls_logits (tf.Tensor 形状为 (batch_size, config.num_labels)) — 分类头的预测分数(即,在类标记的最终隐藏状态之上的线性层)。
  • distillation_logits (tf.Tensor 形状为 (batch_size, config.num_labels)) — 蒸馏头的预测分数(即,在蒸馏标记的最终隐藏状态之上的线性层)。
  • hidden_states (tuple(tf.Tensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — tf.Tensor 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)。每一层输出的模型隐藏状态加上初始嵌入输出。
  • attentions (tuple(tf.Tensor)可选,在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — tf.Tensor 的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

TFDeiTForImageClassificationWithTeacher 正向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFDeiTForImageClassificationWithTeacher
>>> import tensorflow as tf
>>> 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("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")

>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
< > 在 GitHub 上更新