Transformers 4.37 中文文档（七十）（3）-阿里云开发者社区

Transformers 4.37 中文文档（七十）（2）https://developer.aliyun.com/article/1564155

PoolFormerImageProcessor

`class transformers.PoolFormerImageProcessor`

( do_resize: bool = True size: Dict = None crop_pct: int = 0.9 resample: Resampling = <Resampling.BICUBIC: 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 **kwargs )

参数

do_resize (bool，可选，默认为 True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 覆盖。
size (Dict[str, int]可选，默认为 {"shortest_edge" -- 224})：调整大小后的图像大小。可以被 preprocess 方法中的 size 覆盖。如果未设置 crop_pct：

size 为 {"height": h, "width": w}：将图像调整大小为 (h, w)。
size 为 {"shortest_edge": s}：将图像的最短边调整大小为 s，同时保持纵横比。

如果设置了 crop_pct：

size 为 {"height": h, "width": w}：将图像调整大小为 (int(floor(h/crop_pct)), int(floor(w/crop_pct)))
size 为 {"height": c, "width": c}：将图像的最短边调整大小为 int(floor(c/crop_pct)，同时保持纵横比。
size 为 {"shortest_edge": c}：将图像的最短边调整大小为 int(floor(c/crop_pct)，同时保持纵横比。

crop_pct (float，可选，默认为 0.9) — 从中心裁剪图像的百分比。可以被 preprocess 方法中的 crop_pct 覆盖。
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})：应用中心裁剪后的图像大小。仅在 do_center_crop 设置为 True 时有效。可以被 preprocess 方法中的 crop_size 参数覆盖。
rescale_factor (int 或 float，可选，默认为 1/255) — 如果重新缩放图像，则使用的比例因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
do_rescale (bool，可选，默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。
do_normalize (bool，可选，默认为 True) — 控制是否对图像进行标准化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
image_mean (float 或 List[float]，可选，默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行标准化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。
image_std (float 或 List[float]，可选，默认为 IMAGENET_STANDARD_STD) — 如果对图像进行标准化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构建一个 PoolFormer 图像处理器。

`preprocess`

< source >

( images: Union do_resize: bool = None size: Dict = None crop_pct: int = None resample: Resampling = 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 **kwargs )

参数

images (ImageInput) — 要预处理的图像。期望传入像素值范围为 0 到 255 的单个图像或图像批次。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
do_resize (bool，可选，默认为 self.do_resize) — 是否调整图像大小。
size (Dict[str, int]，可选，默认为 self.size) — 调整大小后的图像大小。
crop_pct (float，可选，默认为 self.crop_pct) — 要裁剪的图像百分比。仅在 do_resize 设置为 True 时有效。
resample (int，可选，默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是枚举 PILImageResampling 中的一个。仅当 do_resize 设置为 True 时才有效。
do_center_crop (bool，可选，默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
crop_size (Dict[str, int]，可选，默认为 self.crop_size) — 应用中心裁剪后的图像大小。
do_rescale (bool，可选，默认为 self.do_rescale) — 是否将图像值重新缩放在 [0 - 1] 之间。
rescale_factor (float，可选，默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。
do_normalize (bool，可选，默认为 self.do_normalize) — 是否对图像进行归一化。
image_mean (float 或 List[float]，可选，默认为 self.image_mean) — 图像均值。
image_std (float 或 List[float]，可选，默认为 self.image_std) — 图像标准差。
return_tensors (str 或 TensorType，可选) — 要返回的张量类型。可以是以下之一：

未设置：返回一个 np.ndarray 列表。
TensorType.TENSORFLOW 或 'tf'：返回一个类型为 tf.Tensor 的批次。
TensorType.PYTORCH 或 'pt'：返回一个类型为 torch.Tensor 的批次。
TensorType.NUMPY 或 'np'：返回一个类型为 np.ndarray 的批次。
TensorType.JAX 或 'jax'：返回一个类型为 jax.numpy.ndarray 的批次。

data_format (ChannelDimension 或 str，可选，默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。
ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。

input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

"channels_first" 或 ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。
"channels_last" 或 ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。
"none" 或 ChannelDimension.NONE：图像以 (height, width) 格式。

预处理图像或一批图像。

PoolFormerModel

`class transformers.PoolFormerModel`

<来源>

( config )

参数

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

裸的 PoolFormer 模型变压器，输出原始隐藏状态，没有特定的头部。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

<来源>

( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithNoAttention or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 PoolFormerImageProcessor.call()。

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

一个transformers.modeling_outputs.BaseModelOutputWithNoAttention或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时）包括不同的元素，取决于配置（PoolFormerConfig）和输入。

last_hidden_state（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 模型最后一层的隐藏状态序列输出。
hidden_states（tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或者当config.output_hidden_states=True时返回）— 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型有嵌入层，则一个用于嵌入输出，+ 一个用于每一层的输出）。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

PoolFormerModel 的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, PoolFormerModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("sail/poolformer_s12")
>>> model = PoolFormerModel.from_pretrained("sail/poolformer_s12")
>>> 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, 512, 7, 7]

PoolFormerForImageClassification

`class transformers.PoolFormerForImageClassification`

<来源>

( config )

参数

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

具有图像分类头部的 PoolFormer 模型变压器

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

`forward`

<来源>

( pixel_values: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)

参数

pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 PoolFormerImageProcessor.call()。
labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时）包括不同的元素，取决于配置（PoolFormerConfig）和输入。

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时返回） — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每个阶段的输出）。模型在每个阶段输出的隐藏状态（也称为特征图）。

PoolFormerForImageClassification 的前向方法覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, PoolFormerForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("sail/poolformer_s12")
>>> model = PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12")
>>> 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

金字塔视觉变换器（PVT）

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/pvt

概述

PVT 模型由 Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, Ling Shao 在金字塔视觉变换器：一种用于密集预测的多功能骨干网络而无需卷积中提出。PVT 是一种利用金字塔结构的视觉变换器，使其成为密集预测任务的有效骨干。具体来说，它允许使用更精细的输入（每个补丁 4 x 4 像素），同时随着深度的增加缩短变换器的序列长度，从而降低计算成本。此外，还使用了空间缩减注意力（SRA）层，进一步降低学习高分辨率特征时的资源消耗。

论文摘要如下：

尽管卷积神经网络（CNNs）在计算机视觉领域取得了巨大成功，但本研究探讨了一种简单的、无需卷积的骨干网络，适用于许多密集预测任务。与最近提出的专为图像分类而设计的 Vision Transformer（ViT）不同，我们引入了金字塔视觉变换器（PVT），它克服了将 Transformer 移植到各种密集预测任务的困难。与通常产生低分辨率输出并导致高计算和内存成本的 ViT 不同，PVT 不仅可以在图像的密集分区上进行训练以实现高输出分辨率，这对于密集预测非常重要，而且还使用逐渐缩小的金字塔来减少大特征图的计算量。PVT 继承了 CNN 和 Transformer 的优点，使其成为各种视觉任务的统一骨干，无需卷积，可以直接替代 CNN 骨干。我们通过大量实验证实了 PVT 的有效性，显示它提升了许多下游任务的性能，包括目标检测、实例和语义分割。例如，具有相同参数数量的 PVT+RetinaNet 在 COCO 数据集上实现了 40.4 AP，超过了 ResNet50+RetinNet（36.3 AP）4.1 个绝对 AP（见图 2）。我们希望 PVT 可以作为像素级预测的替代和有用的骨干，并促进未来的研究。

此模型由 Xrenya)贡献。原始代码可在此处找到。

PVTv1 在 ImageNet-1K 上

模型变体	大小	准确率@1	参数（百万）
PVT-Tiny	224	75.1	13.2
PVT-Small	224	79.8	24.5
PVT-Medium	224	81.2	44.2
PVT-Large	224	81.7	61.4

PvtConfig

`class transformers.PvtConfig`

< source >

( image_size: int = 224 num_channels: int = 3 num_encoder_blocks: int = 4 depths: List = [2, 2, 2, 2] sequence_reduction_ratios: List = [8, 4, 2, 1] hidden_sizes: List = [64, 128, 320, 512] patch_sizes: List = [4, 2, 2, 2] strides: List = [4, 2, 2, 2] num_attention_heads: List = [1, 2, 5, 8] mlp_ratios: List = [8, 8, 4, 4] hidden_act: Mapping = 'gelu' hidden_dropout_prob: float = 0.0 attention_probs_dropout_prob: float = 0.0 initializer_range: float = 0.02 drop_path_rate: float = 0.0 layer_norm_eps: float = 1e-06 qkv_bias: bool = True num_labels: int = 1000 **kwargs )

参数

image_size (int, optional, defaults to 224) — 输入图像大小
num_channels (int, optional, defaults to 3) — 输入通道数。
num_encoder_blocks (int, optional, defaults to 4) — 编码器块的数量（即 Mix Transformer 编码器中的阶段数）。
depths (List[int], optional, defaults to [2, 2, 2, 2]) — 每个编码器块中的层数。
sequence_reduction_ratios (List[int], optional, defaults to [8, 4, 2, 1]) — 每个编码器块中的序列缩减比率。
hidden_sizes (List[int], optional, defaults to [64, 128, 320, 512]) — 每个编码器块的维度。
patch_sizes (List[int], optional, defaults to [4, 2, 2, 2]) — 每个编码器块之前的补丁大小。
strides (List[int], optional, defaults to [4, 2, 2, 2]) — 每个编码器块之前的步幅。
num_attention_heads（List[int]，可选，默认为[1, 2, 5, 8]）— 每个 Transformer 编码器块中每个注意力层的注意力头数。
mlp_ratios（List[int]，可选，默认为[8, 8, 4, 4]）— 与 Transformer 编码器块中输入层大小相比的隐藏层大小比例。
hidden_act（str或function，可选，默认为"gelu"）— 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"，"relu"，"selu"和"gelu_new"。
hidden_dropout_prob（float，可选，默认为 0.0）— 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob（float，可选，默认为 0.0）— 注意力概率的 dropout 比率。
initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
drop_path_rate（float，可选，默认为 0.0）— 用于 Transformer 编码器块中随机深度的 dropout 概率。
layer_norm_eps（float，可选，默认为 1e-06）— 层归一化层使用的 epsilon。
qkv_bias（bool，可选，默认为True）— 是否应向查询、键和值添加可学习偏置。
num_labels（int，可选，默认为 1000）— 类别数。

这是一个配置类，用于存储 PvtModel 的配置。根据指定的参数实例化 Pvt 模型，定义模型架构。使用默认值实例化配置将产生类似于 Pvt Xrenya/pvt-tiny-224架构的配置。

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

示例：

>>> from transformers import PvtModel, PvtConfig
>>> # Initializing a PVT Xrenya/pvt-tiny-224 style configuration
>>> configuration = PvtConfig()
>>> # Initializing a model from the Xrenya/pvt-tiny-224 style configuration
>>> model = PvtModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

PvtImageProcessor

`class transformers.PvtImageProcessor`

<来源>

( do_resize: bool = True size: Optional = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

do_resize（bool，可选，默认为True）— 是否将图像的（高度，宽度）尺寸调整为指定的（size["height"]，size["width"]）。可以通过preprocess方法中的do_resize参数覆盖。
size（dict，可选，默认为{"height" -- 224, "width": 224}）：调整大小后的输出图像大小。可以通过preprocess方法中的size参数覆盖。
resample（PILImageResampling，可选，默认为Resampling.BILINEAR）— 如果调整图像大小，则要使用的重采样滤波器。可以通过preprocess方法中的resample参数覆盖。
do_rescale（bool，可选，默认为True）— 是否按指定比例rescale_factor重新缩放图像。可以通过preprocess方法中的do_rescale参数覆盖。
rescale_factor（int或float，可选，默认为1/255）— 如果重新缩放图像，则要使用的比例因子。可以通过preprocess方法中的rescale_factor参数覆盖。
do_normalize（bool，可选，默认为True）— 是否对图像进行归一化。可以通过preprocess方法中的do_normalize参数覆盖。
image_mean（float或List[float]，可选，默认为IMAGENET_DEFAULT_MEAN）— 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以通过preprocess方法中的image_mean参数覆盖。
image_std (float 或 List[float], 可选, 默认为 IMAGENET_DEFAULT_STD) — 如果归一化图像，则使用的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构造一个 PVT 图像处理器。

`预处理`

< source >

( images: Union do_resize: Optional = None size: Dict = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

images (ImageInput) — 要预处理的图像。期望单个图像或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。
do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
size (Dict[str, int], 可选, 默认为 self.size) — 以 {"height": h, "width": w} 格式指定调整大小后输出图像的大小的字典。
resample (PILImageResampling 过滤器, 可选, 默认为 self.resample) — 如果调整图像大小，则使用的 PILImageResampling 过滤器，例如 PILImageResampling.BILINEAR。仅在 do_resize 设置为 True 时有效。
do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放在 [0 - 1] 之间。
rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。
do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 如果 do_normalize 设置为 True，则使用的图像均值。
image_std (float 或 List[float], 可选, 默认为 self.image_std) — 如果 do_normalize 设置为 True，则使用的图像标准差。
return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一：

未设置: 返回一个 np.ndarray 列表。
TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。
TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。
TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。
TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。

data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

"channels_first" 或 ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。
"channels_last" 或 ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。
未设置: 使用输入图像的通道维度格式。

input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

"channels_first" 或 ChannelDimension.FIRST: 图像以 (通道数, 高度, 宽度) 格式。
"channels_last" 或 ChannelDimension.LAST: 图像以 (高度, 宽度, 通道数) 格式。
"none" 或 ChannelDimension.NONE: 图像以 (高度, 宽度) 格式。

预处理一个图像或一批图像。

PvtForImageClassification

`class transformers.PvtForImageClassification`

< source >

( config: PvtConfig )

参数

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

Pvt 模型变压器，顶部带有图像分类头（在 [CLS] 令牌的最终隐藏状态之上的线性层），例如用于 ImageNet。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

< source >

( pixel_values: Optional labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutput or tuple(torch.FloatTensor)

参数

pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 PvtImageProcessor.call()。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[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元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（PvtConfig）和输入。

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时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。模型在每个阶段的输出的隐藏状态（也称为特征图）。
attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

PvtForImageClassification 的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, PvtForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("Zetatech/pvt-tiny-224")
>>> model = PvtForImageClassification.from_pretrained("Zetatech/pvt-tiny-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

PvtModel

`class transformers.PvtModel`

< source >

( config: PvtConfig )

参数

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

裸 Pvt 编码器输出原始隐藏状态，没有特定的头部。这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

`forward`

<来源>

( pixel_values: FloatTensor output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 PvtImageProcessor.call()。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（PvtConfig）和输入不同元素。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每层输出的一个）。
模型在每一层的输出的隐藏状态加上可选的初始嵌入输出。
attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

PvtModel 的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, PvtModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("Zetatech/pvt-tiny-224")
>>> model = PvtModel.from_pretrained("Zetatech/pvt-tiny-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, 50, 512]

Transformers 4.37 中文文档（七十）（4）https://developer.aliyun.com/article/1564157

Transformers 4.37 中文文档（七十）（3）

PoolFormerImageProcessor

`class transformers.PoolFormerImageProcessor`

`preprocess`

PoolFormerModel

`class transformers.PoolFormerModel`

`forward`

PoolFormerForImageClassification

`class transformers.PoolFormerForImageClassification`

`forward`

金字塔视觉变换器（PVT）

概述

PvtConfig

`class transformers.PvtConfig`

PvtImageProcessor

`class transformers.PvtImageProcessor`

`预处理`

PvtForImageClassification

`class transformers.PvtForImageClassification`

`forward`

PvtModel

`class transformers.PvtModel`

`forward`

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（七十）（3）

PoolFormerImageProcessor

class transformers.PoolFormerImageProcessor

preprocess

PoolFormerModel

class transformers.PoolFormerModel

forward

PoolFormerForImageClassification

class transformers.PoolFormerForImageClassification

forward

金字塔视觉变换器（PVT）

概述

PvtConfig

class transformers.PvtConfig

PvtImageProcessor

class transformers.PvtImageProcessor

预处理

PvtForImageClassification

class transformers.PvtForImageClassification

forward

PvtModel

class transformers.PvtModel

forward

热门文章

最新文章

相关电子书

`class transformers.PoolFormerImageProcessor`

`preprocess`

`class transformers.PoolFormerModel`

`forward`

`class transformers.PoolFormerForImageClassification`

`forward`

`class transformers.PvtConfig`

`class transformers.PvtImageProcessor`

`预处理`

`class transformers.PvtForImageClassification`

`forward`

`class transformers.PvtModel`

`forward`