HuggingFace - Vision Transformer (ViT) 模型在

概述

Vision Transformer (ViT) 模型在An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale 中提出, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby. 这是第一篇在 ImageNet 上成功训练 Transformer 编码器的论文，与熟悉的卷积架构相比取得了非常好的结果。

该论文的摘要如下：

虽然 Transformer 架构已成为自然语言处理任务的事实标准，但其在计算机视觉中的应用仍然有限。在视觉中，注意力要么与卷积网络结合使用，要么用于替换卷积网络的某些组件，同时保持其整体结构不变。我们表明，这种对 CNN 的依赖是不必要的，直接应用于图像块序列的纯变换器可以很好地执行图像分类任务。当对大量数据进行预训练并转移到多个中小型图像识别基准（ImageNet、CIFAR-100、VTAB 等）时，Vision Transformer (ViT) 与 state-of-the-艺术卷积网络，同时需要更少的计算资源来训练。

尖端：

• 可以在此处找到有关推理以及对自定义数据微调 ViT 的演示笔记本。
• 为了将图像馈送到 Transformer 编码器，每个图像被分成一系列固定大小的非重叠块，然后线性嵌入。添加 [CLS] 标记作为整个图像的表示，可用于分类。作者还添加了绝对位置嵌入，并将生成的向量序列提供给标准的 Transformer 编码器。
• 由于 Vision Transformer 期望每个图像具有相同的大小（分辨率），因此可以使用ViTImageProcessor调整模型的图像大小（或重新缩放）和标准化。
• 在预训练或微调期间使用的补丁分辨率和图像分辨率都反映在每个检查点的名称中。例如，google/vit-base-patch16-224指的是具有 16x16 的补丁分辨率和 224x224 的微调分辨率的基本尺寸架构。所有检查点都可以在集线器上找到。
• 可用的检查点是 (1) 仅在ImageNet-21k （1400 万张图像和 21k 类的集合）上预训练的，或者 (2) 也在ImageNet（也称为 ILSVRC 2012，1.3 的集合）上进行了微调百万张图片和 1,000 个类别）。
• Vision Transformer 使用 224x224 的分辨率进行了预训练。在微调期间，使用比预训练更高的分辨率通常是有益的(Touvron et al., 2019)，(Kolesnikov et al., 2020)。为了在更高分辨率下进行微调，作者根据它们在原始图像中的位置对预训练位置嵌入进行二维插值。
• 最好的结果是通过有监督的预训练获得的，而在 NLP 中则不是这样。作者还进行了一项具有自我监督预训练目标的实验，即蒙面补丁预测（受蒙面语言建模启发）。通过这种方法，较小的 ViT-B/16 模型在 ImageNet 上达到了 79.9% 的准确率，比从头开始训练有 2% 的显着提高，但仍落后于有监督的预训练 4%。

虚拟架构。取自原始论文。

继最初的 Vision Transformer 之后，又做了一些后续作品：

• Facebook AI 的DeiT（数据高效图像转换器）。DeiT 模型是经过提炼的视觉转换器。DeiT 的作者还发布了经过更高效训练的 ViT 模型，您可以将其直接插入ViTModel或ViTForImageClassification中。有 4 种变体可用（3 种不同大小）：facebook/deit-tiny-patch16-224、facebook/deit-small-patch16-224、facebook/deit-base-patch16-224和facebook/deit-base-patch16- 384。请注意，应使用DeiTImageProcessor为模型准备图像。

• Microsoft Research 的BEiT（图像转换器的 BERT 预训练）。BEiT 模型使用受 BERT（蒙版图像建模）启发并基于 VQ-VAE 的自监督方法，其性能优于受监督的预训练视觉变换器。

• Facebook AI 的 DINO（Vision Transformers 的自我监督训练方法）。使用 DINO 方法训练的 Vision Transformers 显示出卷积模型所没有的非常有趣的特性。他们能够分割物体，而无需接受过这样的训练。可以在集线器上找到 DINO 检查点。

• Facebook AI 的MAE（掩码自动编码器）。通过对 Vision Transformers 进行预训练以重建大部分 (75%) 蒙版块的像素值（使用非对称编码器-解码器架构），作者表明这种简单的方法优于微调后的监督预训练。

这个模型是由nielsr贡献的。可以在此处找到原始代码（用 JAX 编写）。

请注意，我们从 Ross Wightman 的timm 库转换了权重，该库已经将权重从 JAX 转换为 PyTorch。功劳归于他！

资源

官方 Hugging Face 和社区（由 🌎 表示）资源列表，可帮助您开始使用 ViT。

图片分类

• 此示例脚本和笔记本支持ViTForImageClassification。
• 可以在此处找到有关在自定义数据集上微调ViTForImageClassification的博客。
• 可以在此处找到更多用于微调ViTForImageClassification的演示笔记本。
• 图像分类任务指南

除此之外：

• 此示例脚本支持ViTForMaskedImageModeling。

如果您有兴趣提交要包含在此处的资源，请随时打开合并请求，我们将对其进行审核！理想情况下，该资源应该展示一些新的东西，而不是复制现有资源。

资源

官方 Hugging Face 和社区（由 🌎 表示）资源列表，可帮助您开始使用 ViT。如果您有兴趣提交要包含在此处的资源，请随时打开合并请求，我们将对其进行审核！理想情况下，该资源应该展示一些新的东西，而不是复制现有资源。

ViTForImageClassification支持：

图片分类

• 一篇关于如何使用Hugging Face Transformers 微调 ViT 以进行图像分类的博文
• 一篇关于使用 Hugging Face Transformers 和 进行图像分类的博文Keras
• 关于使用拥抱面变换器对图像分类进行微调的笔记本
• 关于如何使用 Hugging Face Trainer 在 CIFAR-10 上微调 Vision Transformer 的笔记本
• 关于如何使用 PyTorch Lightning 在 CIFAR-10 上微调 Vision Transformer 的笔记本

⚗️优化

• 一篇关于如何使用 Optimum 通过量化加速 Vision Transformer (ViT) 的博文

⚡️ 推理

• 关于快速演示的笔记本：Google Brain 的 Vision Transformer (ViT)

🚀 部署

• 一篇关于使用 TF 服务在拥抱面中部署 Tensorflow 视觉模型的博文
• 关于在 Vertex AI 上部署 Hugging Face ViT的博文
• 关于使用 TF 服务在 Kubernetes 上部署 Hugging Face ViT 的博文

ViTConfig

类 变压器。ViTConfig

<来源>

( 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_channel s = 3 qkv_bias = True encoder_stride = 16 **kwargs )

参数

• hidden_​​size ( int, optional , defaults to 768) — 编码层和池化层的维数。
• num_hidden_​​layers ( int, optional , defaults to 12) — Transformer 编码器中的隐藏层数。
• num_attention_heads ( int, optional , defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size ( int, optional , defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维数。
• hidden_​​act ( stror function, optional , defaults to "gelu") — 编码器和 pooler 中的非线性激活函数（函数或字符串）。如果支持字符串、"gelu"、"relu"和"selu"。"gelu_new"
• hidden_​​dropout_prob ( float, optional , defaults to 0.1) — 嵌入、编码器和池化器中所有完全连接层的丢失概率。
• attention_probs_dropout_prob ( float, optional , defaults to 0.1) — 注意概率的丢失率。
• initializer_range ( float, optional , defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
• layer_norm_eps ( float, optional , defaults to 1e-12) — 层归一化层使用的 epsilon。
• image_size ( int, optional , defaults to 224) — 每个图像的大小（分辨率）。
• patch_size ( int, optional , defaults to 16) — 每个补丁的大小（分辨率）。
• num_channels ( int, optional , defaults to 3) — 输入通道的数量。
• qkv_bias ( bool, optional , defaults to True) — 是否向查询、键和值添加偏差。
• encoder_stride ( int, optional, defaults to 16) — 在解码器头中增加空间分辨率的因素，用于掩码图像建模。

这是存储ViTModel配置的配置类。它用于根据指定的参数实例化 ViT 模型，定义模型架构。使用默认值实例化配置将产生与 ViT google/vit-base-patch16-224架构类似的配置。

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

例子：

已复制

>>>从变压器导入ViTConfig、ViTModel

>>> # 初始化一个 ViT vit-base-patch16-224 风格的配置
>>> configuration = ViTConfig()

>>> # 从 vit-base-patch16-224 样式配置初始化模型（具有随机权重）
>>> model = ViTModel(configuration)

>>> # 访问模型配置
>>> configuration = model.config

ViT特征提取器

类 变压器。ViT特征提取器

<来源>

( *参数 **kwargs )

__称呼__

<来源>

( 图片 **kwargs )

预处理图像或一批图像。

ViT图像处理器

类 变压器。ViT图像处理器

<来源>

（ do_resize ：bool = True size ：typing.Union[typing.Dict[str, int], NoneType] = None resample ：Resampling = <Resampling.BILINEAR: 2> 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, optional , defaults to True) — 是否将图像的（高度、宽度）尺寸调整为指定的尺寸(size["height"], size["width"])。可以被方法do_resize中的参数覆盖preprocess。
• size ( dict, optional , defaults to {"height" -- 224, "width": 224}): 调整大小后输出图像的大小。可以被方法size中的参数覆盖preprocess。
• resample ( PILImageResampling, optional , defaults to PILImageResampling.BILINEAR) — 调整图像大小时使用的重采样过滤器。可以被方法resample中的参数覆盖preprocess。
• do_rescale ( bool, optional , defaults to True) — 是否按指定比例重新缩放图像rescale_factor。可以被方法do_rescale中的参数覆盖preprocess。
• rescale_factor ( intor float, optional , defaults to 1/255) — 重新缩放图像时使用的比例因子。可以被方法rescale_factor中的参数覆盖preprocess。do_normalize — 是否规范化图像。可以被方法do_normalize中的参数覆盖preprocess。
• image_mean ( floator List[float], optional , defaults to IMAGENET_STANDARD_MEAN) — 对图像进行标准化时使用的均值。这是一个浮点数或浮点数列表，长度为图像中的通道数。可以被方法image_mean中的参数覆盖preprocess。
• image_std ( floator List[float], optional , defaults to IMAGENET_STANDARD_STD) — 规范化图像时使用的标准偏差。这是一个浮点数或浮点数列表，长度为图像中的通道数。可以被方法image_std中的参数覆盖preprocess。

构造一个 ViT 图像处理器。

预处理

<来源>

（ 图片：typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List [numpy.ndarray], typing.List[ForwardRef('torch.Tensor')]] do_resize : typing.Optional[bool] = None size : typing.Dict[str, int] = None resample : Resampling = None do_rescale : 打字.Optional[bool] = None rescale_factor : typing.Optional[float] = None do_normalize : typing.Optional[bool] = None image_mean : typing.Union[float, typing.List[float], NoneType] = None image_std : 打字。 Union[float, typing.List[float], NoneType] = None 返回张量: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = 无 data_format : typing.Union[str, transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> **kwargs )

参数

• images ( ImageInput) — 要预处理的图像。
• do_resize ( bool, optional , defaults to self.do_resize) — 是否调整图像大小。
• size ( Dict[str, int], optional , defaults to self.size) — 格式{"height": h, "width": w}为调整大小后指定输出图像大小的字典。
• resample ( PILImageResamplingfilter, optional , defaults to self.resample) —PILImageResampling调整图像大小时使用的过滤器，例如PILImageResampling.BILINEAR。do_resize只有设置为 时才有效True。
• do_rescale ( bool, optional , defaults to self.do_rescale) — 是否重新缩放 [0 - 1] 之间的图像值。
• rescale_factor ( float, optional , defaults to ) — 如果设置为self.rescale_factor，则重新缩放图像的重新缩放因子。do_rescaleTrue
• do_normalize ( bool, optional , defaults to self.do_normalize) — 是否规范化图像。
• image_mean（float或List[float]，可选，默认为）——如果设置为self.image_mean，则使用的图像均值。do_normalizeTrue
• image_std（float或List[float]，可选，默认为self.image_std）— 如果do_normalize设置为则使用的图像标准差True。
• return_tensors ( stror TensorType, optional ) — 要返回的张量的类型。可以是以下之一：
  • 取消设置：返回一个列表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 ( ChannelDimensionor str, optional , defaults to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • "channels_first"或ChannelDimension.FIRST: (num_channels, height, width) 格式的图像。
  • "channels_last"或ChannelDimension.LAST: (height, width, num_channels) 格式的图像。
  • Unset：使用输入图像的通道维度格式。

预处理图像或图像批次。

ViT模型

类 变压器。ViT模型

<来源>

（ 配置：ViTConfig add_pooling_layer ：bool = True use_mask_token ：bool = False ）

参数

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

裸露的 ViT 模型转换器输出原始隐藏状态，顶部没有任何特定的头部。这个模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

向前

<来源>

( pixel_values : typing.Optional[torch.Tensor] = None bool_masked_pos : typing.Optional[torch.BoolTensor] = None head_mask : typing.Optional[torch.Tensor] = None output_attentions : typing.Optional[bool] = None output_hidden_​​states : typing .Optional[bool] = None interpolate_pos_encoding : typing.Optional[bool] = None return_dict : typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling或tuple(torch.FloatTensor)

参数

• pixel_values ( torch.FloatTensorof shape (batch_size, num_channels, height, width)) — 像素值。可以使用AutoImageProcessor获取像素值。请参阅ViTImageProcessor。致电（）了解详情。
• head_mask（torch.FloatTensor形状为(num_heads,)or (num_layers, num_heads)，可选）— 使自注意力模块的选定头部无效的掩码。在以下位置选择的掩码值[0, 1]：
  • 1表示头部没有被遮盖，
  • 0 表示头部被屏蔽。
• output_attentions ( bool, optional ) — 是否返回所有注意力层的注意力张量。attentions有关更多详细信息，请参阅返回的张量。
• output_hidden_​​states ( bool, optional ) — 是否返回所有层的隐藏状态。hidden_states有关更多详细信息，请参阅返回的张量。
• interpolate_pos_encoding ( bool, optional ) — 是否插入预训练位置编码。
• return_dict ( bool, optional ) — 是否返回 ModelOutput而不是普通元组。
• bool_masked_pos ( torch.BoolTensorof shape (batch_size, num_patches), optional ) — 布尔掩码位置。指示哪些补丁被屏蔽 (1) 哪些不是 (0)。

退货

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

一个transformers.modeling_outputs.BaseModelOutputWithPooling或一个元组torch.FloatTensor（if return_dict=Falseis passed or when config.return_dict=False）包含取决于配置（ViTConfig）和输入的各种元素。

• last_hidden_​​state ( torch.FloatTensorof shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

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

• hidden_​​states ( tuple(torch.FloatTensor), optional , returned when output_hidden_states=Trueis passed or when config.output_hidden_states=True) — shape 的元组torch.FloatTensor（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个层的输出）(batch_size, sequence_length, hidden_size)。

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

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

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

ViTModel forward 方法覆盖了特殊__call__方法。

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

例子：

已复制

>>> from transformers import AutoImageProcessor, ViTModel
 >>> import torch
 >>> from datasets导入load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224-in21k" )
 >>> model = ViTModel.from_pretrained( "google/vit-base-patch16-224-in21k" )

>>> inputs = image_processor（图像，return_tensors = “pt”）

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

>>> last_hidden_​​states = outputs.last_hidden_​​state
 >>>列表（last_hidden_​​states.shape）
[ 1 , 197 , 768 ]

ViTForMaskedImageModeling

类 变压器。ViTForMaskedImageModeling

<来源>

（ 配置：ViTConfig ）

参数

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

ViT 模型，顶部带有解码器，用于蒙版图像建模，如SimMIM中所提议。

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

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

向前

<来源>

( pixel_values : typing.Optional[torch.Tensor] = None bool_masked_pos : typing.Optional[torch.BoolTensor] = None head_mask : typing.Optional[torch.Tensor] = None output_attentions : typing.Optional[bool] = None output_hidden_​​states : typing .Optional[bool] = None interpolate_pos_encoding : typing.Optional[bool] = None return_dict : typing.Optional[bool] = None ) → 或transformers.modeling_outputs.MaskedImageModelingOutputtuple(torch.FloatTensor)

参数

• pixel_values ( torch.FloatTensorof shape (batch_size, num_channels, height, width)) — 像素值。可以使用AutoImageProcessor获取像素值。请参阅ViTImageProcessor。致电（）了解详情。
• head_mask（torch.FloatTensor形状为(num_heads,)or (num_layers, num_heads)，可选）— 使自注意力模块的选定头部无效的掩码。在以下位置选择的掩码值[0, 1]：
  • 1表示头部没有被遮盖，
  • 0 表示头部被屏蔽。
• output_attentions ( bool, optional ) — 是否返回所有注意力层的注意力张量。attentions有关更多详细信息，请参阅返回的张量。
• output_hidden_​​states ( bool, optional ) — 是否返回所有层的隐藏状态。hidden_states有关更多详细信息，请参阅返回的张量。
• interpolate_pos_encoding ( bool, optional ) — 是否插入预训练位置编码。
• return_dict ( bool, optional ) — 是否返回 ModelOutput而不是普通元组。
• bool_masked_pos ( torch.BoolTensorof shape (batch_size, num_patches)) — 布尔掩码位置。指示哪些补丁被屏蔽 (1) 哪些不是 (0)。

退货

transformers.modeling_outputs.MaskedImageModelingOutput或者tuple(torch.FloatTensor)

一个transformers.modeling_outputs.MaskedImageModelingOutput或一个元组torch.FloatTensor（if return_dict=Falseis passed or when config.return_dict=False）包含各种元素，具体取决于配置（ViTConfig）和输入。

• 损失（torch.FloatTensor形状(1,)，可选bool_masked_pos，提供时返回）—重建损失。
• 重建（torch.FloatTensor形状(batch_size, num_channels, height, width)）——重建/完成的图像。
• hidden_​​states ( tuple(torch.FloatTensor), optional , 当output_hidden_states=True传递或
• when config.output_hidden_states=True ) — shape 的元组torch.FloatTensor（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个阶段的输出）(batch_size, sequence_length, hidden_size)。模型在每个阶段输出的隐藏状态（也称为特征图）。
• attentions ( tuple(torch.FloatTensor), optional , 当output_attentions=True通过或当
• config.output_attentions=True):形状的元组torch.FloatTensor（每层一个）(batch_size, num_heads, patch_size, sequence_length)。注意 softmax 之后的注意权重，用于计算自注意头中的加权平均值。

ViTForMaskedImageModeling转发方法，覆盖__call__特殊方法。

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

例子：

已复制

>>> from transformers import AutoImageProcessor, ViTForMaskedImageModeling
 >>> import torch
 >>> from PIL import Image
 >>>导入请求

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" 
>>> image = 图片。打开(requests.get(url, stream= True ).raw)

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224-in21k" )
 >>> model = ViTForMaskedImageModeling.from_pretrained( "google/vit-base-patch16-224-in21k" )

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2 
>>> pixel_values = image_processor(images=image, return_tensors= "pt" ).pixel_values
 >>> # 创建随机布尔掩码shape (batch_size, num_patches) 
>>> bool_masked_pos = torch.randint(low= 0 , high= 2 , size=( 1 , num_patches)). 布尔值（）

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

ViTFor图像分类

类 变压器。ViTFor图像分类

<来源>

（ 配置：ViTConfig ）

参数

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

顶部带有图像分类头的 ViT 模型转换器（[CLS] 令牌最终隐藏状态顶部的线性层）例如 ImageNet。

请注意，通过在模型的前面设置interpolate_pos_encoding为，可以在比训练过的图像更高分辨率的图像上微调 ViT 。True这会将预训练的位置嵌入内插到更高分辨率。

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

向前

<来源>

( pixel_values : typing.Optional[torch.Tensor] = None head_mask : typing.Optional[torch.Tensor] = None labels : typing.Optional[torch.Tensor] = None output_attentions : typing.Optional[bool] = None output_hidden_​​states : typing .Optional[bool] = None interpolate_pos_encoding : typing.Optional[bool] = None return_dict : typing.Optional[bool] = None ) → transformers.modeling_outputs.ImageClassifierOutput或tuple(torch.FloatTensor)

参数

• pixel_values ( torch.FloatTensorof shape (batch_size, num_channels, height, width)) — 像素值。可以使用AutoImageProcessor获取像素值。请参阅ViTImageProcessor。致电（）了解详情。
• head_mask（torch.FloatTensor形状为(num_heads,)or (num_layers, num_heads)，可选）— 使自注意力模块的选定头部无效的掩码。在以下位置选择的掩码值[0, 1]：
  • 1表示头部没有被遮盖，
  • 0 表示头部被屏蔽。
• output_attentions ( bool, optional ) — 是否返回所有注意力层的注意力张量。attentions有关更多详细信息，请参阅返回的张量。
• output_hidden_​​states ( bool, optional ) — 是否返回所有层的隐藏状态。hidden_states有关更多详细信息，请参阅返回的张量。
• interpolate_pos_encoding ( bool, optional ) — 是否插入预训练位置编码。
• return_dict ( bool, optional ) — 是否返回 ModelOutput而不是普通元组。
• labels ( torch.LongTensorof shape (batch_size,), optional ) — 用于计算图像分类/回归损失的标签。指数应该在[0, ..., config.num_labels - 1]. 如果config.num_labels == 1计算回归损失（均方损失），如果config.num_labels > 1计算分类损失（交叉熵）。

退货

transformers.modeling_outputs.ImageClassifierOutput或tuple(torch.FloatTensor)

一个transformers.modeling_outputs.ImageClassifierOutput或一个元组torch.FloatTensor（if return_dict=Falseis passed 或 when config.return_dict=False）包含各种元素，具体取决于配置 ( ViTConfig ) 和输入。

• loss ( torch.FloatTensorof shape (1,), optional , returned when labelsis provided) — 分类（或回归，如果 config.num_labels==1）损失。

• logits ( torch.FloatTensorof shape (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（在 SoftMax 之前）。

• hidden_​​states ( tuple(torch.FloatTensor), optional , returned when output_hidden_states=Trueis 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=Trueis passed or when config.output_attentions=True) — 形状的元组torch.FloatTensor（每层一个）(batch_size, num_heads, patch_size, sequence_length)。

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

ViTForImageClassification转发方法，覆盖__call__特殊方法。

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

例子：

已复制

>>> from transformers import AutoImageProcessor, ViTForImageClassification
 >>> import torch
 >>> from datasets导入load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224" )
 >>> model = ViTForImageClassification.from_pretrained( "google/vit-base-patch16-224" )

>>> inputs = image_processor（图像，return_tensors = “pt”）

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

>>> # 模型预测 1000 个 ImageNet 类之一
>>> predicted_label = logits.argmax(- 1 ).item()
 >>> print (model.config.id2label[predicted_label])
埃及猫

TFViT模型

类 变压器。TFViT模型

<来源>

( *参数 **kwargs )

参数

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

裸露的 ViT 模型转换器输出原始隐藏状态，顶部没有任何特定的头部。

该模型继承自TFPreTrainedModel。检查超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头等）

该模型也是tf.keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与一般用法和行为相关的所有事项。

TensorFlow 模型和层transformers接受两种格式作为输入：

• 将所有输入作为关键字参数（如 PyTorch 模型），或
• 在第一个位置参数中将所有输入作为列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如model.fit()things 之类的方法时，things should “just work” for you - 只需以model.fit()支持的任何格式传递您的输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如fit()和predict()，例如在使用 Keras FunctionalAPI 创建自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量:

• 只有一个张量pixel_values，没有别的：model(pixel_values)
• 在文档字符串中给出的顺序中包含一个或多个输入张量的可变长度列表：model([pixel_values, attention_mask])或model([pixel_values, attention_mask, token_type_ids])
• 一个字典，其中有一个或多个输入张量与文档字符串中给出的输入名称相关联：model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})

请注意，在创建带有子类的模型和图层时，您无需担心这些，因为您可以像将输入传递给任何其他 Python 函数一样将输入传递给任何人！

称呼

<来源>

( pixel_values : typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor]，typing.Dict[str，numpy.ndarray]，typing.Dict[str，keras.engine.keras_tensor.KerasTensor]，tensorflow.python.framework.ops.Tensor，numpy.ndarray , keras.engine.keras_tensor.KerasTensor, NoneType] = None head_mask : typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None output_attentions : typing.Optional[bool] = None output_hidden_​​states : 打字.Optional[bool] = None interpolate_pos_encoding : typing.Optional[bool] = None return_dict: typing.Optional[bool] = None training : bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling或tuple(tf.Tensor)

参数

• pixel_values ( np.ndarray, tf.Tensor, List[tf.Tensor]` Dict[str, tf.Tensor]or Dict[str, np.ndarray]and each example must have the shape (batch_size, num_channels, height, width)) — 像素值。可以使用AutoImageProcessor获取像素值。请参阅ViTImageProcessor。致电（）了解详情。
• head_mask ( np.ndarrayor tf.Tensorof 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有关更多详细信息，请参阅返回的张量。此参数只能在急切模式下使用，在图形模式下，将使用配置中的值。
• interpolate_pos_encoding ( bool, optional ) — 是否插入预训练位置编码。
• return_dict ( bool, optional ) — 是否返回 ModelOutput而不是普通元组。此参数可以在急切模式下使用，在图形模式下，该值将始终设置为 True。
• training ( bool, optional , defaults to `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

退货

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling或tuple(tf.Tensor)

一个transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling或一个元组tf.Tensor（if return_dict=Falseis passed or when config.return_dict=False）包含取决于配置（ViTConfig）和输入的各种元素。

• last_hidden_​​state ( tf.Tensorof shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

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

  该输出通常不是对输入语义内容的良好总结，您通常最好对整个输入序列的隐藏状态序列进行平均或合并。

• hidden_​​states ( tuple(tf.Tensor), optional , returned when output_hidden_states=Trueis passed or when config.output_hidden_states=True) — shape 的元组tf.Tensor（一个用于嵌入的输出 + 一个用于每一层的输出）(batch_size, sequence_length, hidden_size)。

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

• attentions ( tuple(tf.Tensor), optional , returned when output_attentions=Trueis passed or when config.output_attentions=True) — 形状的元组tf.Tensor（每层一个）(batch_size, num_heads, sequence_length, sequence_length)。

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

TFViTModel转发方法，覆盖__call__特殊方法。

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

例子：

已复制

>>>从变压器导入AutoImageProcessor、TFViTModel
 >>>从数据集导入load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224-in21k" )
 >>> model = TFViTModel.from_pretrained( "google/vit-base-patch16-224-in21k" )

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

>>> last_hidden_​​states = outputs.last_hidden_​​state
 >>>列表（last_hidden_​​states.shape）
[ 1 , 197 , 768 ]

TFViTForImageClassification

类 变压器。TFViTForImageClassification

<来源>

( *参数 **kwargs )

参数

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

顶部带有图像分类头的 ViT 模型转换器（[CLS] 令牌最终隐藏状态顶部的线性层）例如 ImageNet。

请注意，通过在模型的前面设置interpolate_pos_encoding为，可以在比训练过的图像更高分辨率的图像上微调 ViT 。True这会将预训练的位置嵌入内插到更高分辨率。

该模型继承自TFPreTrainedModel。检查超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头等）

该模型也是tf.keras.Model 的子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与一般用法和行为相关的所有事项。

TensorFlow 模型和层transformers接受两种格式作为输入：

• 将所有输入作为关键字参数（如 PyTorch 模型），或
• 在第一个位置参数中将所有输入作为列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如model.fit()things 之类的方法时，things should “just work” for you - 只需以model.fit()支持的任何格式传递您的输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如fit()和predict()，例如在使用 Keras FunctionalAPI 创建自己的层或模型时，您可以使用三种可能性来收集第一个位置参数中的所有输入张量:

• 只有一个张量pixel_values，没有别的：model(pixel_values)
• 在文档字符串中给出的顺序中包含一个或多个输入张量的可变长度列表：model([pixel_values, attention_mask])或model([pixel_values, attention_mask, token_type_ids])
• 一个字典，其中有一个或多个输入张量与文档字符串中给出的输入名称相关联：model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})

请注意，在创建带有子类的模型和图层时，您无需担心这些，因为您可以像将输入传递给任何其他 Python 函数一样将输入传递给任何人！

称呼

<来源>

( pixel_values : typing.Union[typing.List[tensorflow.python.framework.ops.Tensor], typing.List[numpy.ndarray], typing.List[keras.engine.keras_tensor.KerasTensor], typing.Dict[str, tensorflow.python.framework.ops.Tensor]，typing.Dict[str，numpy.ndarray]，typing.Dict[str，keras.engine.keras_tensor.KerasTensor]，tensorflow.python.framework.ops.Tensor，numpy.ndarray , keras.engine.keras_tensor.KerasTensor, NoneType] = None head_mask : typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None output_attentions : typing.Optional[bool] = None output_hidden_​​states : 打字.Optional[bool] = None interpolate_pos_encoding : typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels : typing.Union[numpy.ndarray, tensorflow.python.framework.ops.Tensor, NoneType] = None training : typing.Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput或者tuple(tf.Tensor)

参数

• pixel_values ( np.ndarray, tf.Tensor, List[tf.Tensor]` Dict[str, tf.Tensor]or Dict[str, np.ndarray]and each example must have the shape (batch_size, num_channels, height, width)) — 像素值。可以使用AutoImageProcessor获取像素值。请参阅ViTImageProcessor。致电（）了解详情。
• head_mask ( np.ndarrayor tf.Tensorof 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有关更多详细信息，请参阅返回的张量。此参数只能在急切模式下使用，在图形模式下，将使用配置中的值。
• interpolate_pos_encoding ( bool, optional ) — 是否插入预训练位置编码。
• return_dict ( bool, optional ) — 是否返回 ModelOutput而不是普通元组。此参数可以在急切模式下使用，在图形模式下，该值将始终设置为 True。
• training ( bool, optional , defaults to `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• labels（tf.Tensor或np.ndarrayof shape (batch_size,)，可选）— 用于计算图像分类/回归损失的标签。指数应该在[0, ..., config.num_labels - 1]. 如果config.num_labels == 1计算回归损失（均方损失），如果config.num_labels > 1计算分类损失（交叉熵）。

退货

transformers.modeling_tf_outputs.TFSequenceClassifierOutput或tuple(tf.Tensor)

一个transformers.modeling_tf_outputs.TFSequenceClassifierOutput或一个元组tf.Tensor（if return_dict=Falseis passed 或 when config.return_dict=False）包含各种元素，具体取决于配置 ( ViTConfig ) 和输入。

• loss ( tf.Tensorof shape (batch_size, ), optional , returned when labelsis provided) — 分类（或回归，如果 config.num_labels==1）损失。

• logits ( tf.Tensorof shape (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（在 SoftMax 之前）。

• hidden_​​states ( tuple(tf.Tensor), optional , returned when output_hidden_states=Trueis passed or when config.output_hidden_states=True) — shape 的元组tf.Tensor（一个用于嵌入的输出 + 一个用于每一层的输出）(batch_size, sequence_length, hidden_size)。

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

• attentions ( tuple(tf.Tensor), optional , returned when output_attentions=Trueis passed or when config.output_attentions=True) — 形状的元组tf.Tensor（每层一个）(batch_size, num_heads, sequence_length, sequence_length)。

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

TFViTForImageClassification转发方法，覆盖__call__特殊方法。

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

例子：

已复制

>>> from transformers import AutoImageProcessor, TFViTForImageClassification
 >>> import tensorflow as tf
 >>> from datasets导入load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224" )
 >>> model = TFViTForImageClassification.from_pretrained( "google/vit-base-patch16-224" )

>>> inputs = image_processor(image, return_tensors= "tf" )
 >>> logits = model(**inputs).logits 复制代码

>>> # 模型预测 1000 个 ImageNet 类之一
>>> predicted_label = int (tf.math.argmax(logits, axis=- 1 ))
 >>> print (model.config.id2label[predicted_label])
埃及猫

FlaxVit模型

类 变压器。FlaxViT模型

<来源>

（ 配置：ViTConfig input_shape = None seed ：int = 0 dtype ：dtype = <class 'jax.numpy.float32'> _do_init ：bool = True **kwargs )

参数

• config ( ViTConfig ) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看from_pretrained()方法加载模型权重。
• dtype ( jax.numpy.dtype, optional , defaults to jax.numpy.float32) — 计算的数据类型。jax.numpy.float32可以是, jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的执行dtype。

  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅to_fp16()和to_bf16()。

裸露的 ViT 模型转换器输出原始隐藏状态，顶部没有任何特定的头部。

该模型继承自FlaxPreTrainedModel。检查超类文档，了解库为其所有模型实现的通用方法（例如从 PyTorch 模型下载、保存和转换权重）

该模型也是 Flax Linen flax.linen.Module 的子类。将其用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。

最后，该模型支持固有的 JAX 特性，例如：

• 即时 (JIT) 编译
• 自动微分
• 矢量化
• 并行化

__称呼__

<来源>

( 像素值 参数： 字典=无dropout_rng ：PRNGKey =无火车 ：布尔= 假.FlaxBaseModelOutputWithPooling或tuple(torch.FloatTensor)

退货

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling或tuple(torch.FloatTensor)

一个transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling或一个元组torch.FloatTensor（if return_dict=Falseis passed or when config.return_dict=False）包含取决于配置（<class 'transformers.models.vit.configuration_vit.ViTConfig'>）和输入的各种元素。

• last_hidden_​​state ( jnp.ndarrayof shape (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

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

• hidden_​​states ( tuple(jnp.ndarray), optional , returned when output_hidden_states=Trueis passed or when config.output_hidden_states=True) — shape 的元组jnp.ndarray（一个用于嵌入的输出 + 一个用于每一层的输出）(batch_size, sequence_length, hidden_size)。

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

• attentions ( tuple(jnp.ndarray), optional , returned when output_attentions=Trueis passed or when config.output_attentions=True) — 形状的元组jnp.ndarray（每层一个）(batch_size, num_heads, sequence_length, sequence_length)。

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

转发FlaxViTPreTrainedModel方法，覆盖__call__特殊方法。

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

例子：

已复制

>>> from transformers import AutoImageProcessor, FlaxViTModel
 >>> from PIL import Image
 >>>导入请求

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" 
>>> image = 图片。打开(requests.get(url, stream= True ).raw)

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224-in21k" )
 >>> model = FlaxViTModel.from_pretrained( "google/vit-base-patch16-224-in21k" )

>>> inputs = image_processor(images=image, return_tensors= "np" )
 >>> outputs = model(**inputs)
 >>> last_hidden_​​states = outputs.last_hidden_​​state 复制代码

FlaxViTForImageClassification

类 变压器。FlaxViTForImageClassification

<来源>

（ 配置：ViTConfig input_shape = None seed ：int = 0 dtype ：dtype = <class 'jax.numpy.float32'> _do_init ：bool = True **kwargs )

参数

• config ( ViTConfig ) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看from_pretrained()方法加载模型权重。
• dtype ( jax.numpy.dtype, optional , defaults to jax.numpy.float32) — 计算的数据类型。jax.numpy.float32可以是, jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的执行dtype。

  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。

  如果您希望更改模型参数的数据类型，请参阅to_fp16()和to_bf16()。

顶部带有图像分类头的 ViT 模型转换器（[CLS] 令牌最终隐藏状态顶部的线性层）例如 ImageNet。

该模型继承自FlaxPreTrainedModel。检查超类文档，了解库为其所有模型实现的通用方法（例如从 PyTorch 模型下载、保存和转换权重）

该模型也是 Flax Linen flax.linen.Module 的子类。将其用作常规 Flax linen 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。

最后，该模型支持固有的 JAX 特性，例如：

• 即时 (JIT) 编译
• 自动微分
• 矢量化
• 并行化

__称呼__

<来源>

( 像素值 参数： 字典=无dropout_rng ：PRNGKey =无火车 ：布尔= 假.FlaxSequenceClassifierOutput或tuple(torch.FloatTensor)

退货

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput或tuple(torch.FloatTensor)

一个transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput或一个元组torch.FloatTensor（if return_dict=Falseis passed or when config.return_dict=False）包含取决于配置 ( <class 'transformers.models.vit.configuration_vit.ViTConfig'>) 和输入的各种元素。

• logits ( jnp.ndarrayof shape (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（在 SoftMax 之前）。

• hidden_​​states ( tuple(jnp.ndarray), optional , returned when output_hidden_states=Trueis passed or when config.output_hidden_states=True) — shape 的元组jnp.ndarray（一个用于嵌入的输出 + 一个用于每一层的输出）(batch_size, sequence_length, hidden_size)。

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

• attentions ( tuple(jnp.ndarray), optional , returned when output_attentions=Trueis passed or when config.output_attentions=True) — 形状的元组jnp.ndarray（每层一个）(batch_size, num_heads, sequence_length, sequence_length)。

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

转发FlaxViTPreTrainedModel方法，覆盖__call__特殊方法。

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

例子：

已复制

>>> from transformers import AutoImageProcessor, FlaxViTForImageClassification
 >>> from PIL import Image
 >>> import jax
 >>>导入请求

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" 
>>> image = 图片。打开(requests.get(url, stream= True ).raw)

>>> image_processor = AutoImageProcessor.from_pretrained( "google/vit-base-patch16-224" )
 >>> model = FlaxViTForImageClassification.from_pretrained( "google/vit-base-patch16-224" )

>>> inputs = image_processor(images=image, return_tensors= "np" )
 >>> outputs = model(**inputs)
 >>> logits = outputs.logits 复制代码

>>> # 模型预测 1000 个 ImageNet 类之一
>>> predicted_class_idx = jax.numpy.argmax(logits, axis=- 1 )
 >>> print ( "Predicted class:" , model.config.id2label[predicted_class_idx.item ()])