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

Transformers 4.37 中文文档（六十八）（2）https://developer.aliyun.com/article/1564092

ImageGPTForCausalImageModeling

`class transformers.ImageGPTForCausalImageModeling`

( config: ImageGPTConfig )

参数

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

ImageGPT 模型变压器，顶部带有语言建模头（线性层，其权重与输入嵌入层绑定）。

此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存，调整输入嵌入大小，修剪头等）。

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

`forward`

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs: Any ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇中输入序列标记的索引。
如果使用past_key_values，则只应将尚未计算其过去的input_ids作为input_ids传递。
可以使用 AutoImageProcessor 获取索引。有关详细信息，请参阅 ImageGPTImageProcessor.call()。
past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已将其过去给予此模型的input_ids不应作为input_ids传递，因为它们已经计算过。
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

对于未被“掩盖”的标记为 1，
对于被“掩盖”的标记。

什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

0 对应于句子 A标记，
1 对应于句子 B标记。

什么是令牌类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]中：

1 表示头部未被“掩盖”。
0 表示头部被“掩盖”。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
如果使用past_key_values，则可以选择仅输入最后的inputs_embeds（请参阅past_key_values）。
use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor的形状为(batch_size, sequence_length)，optional) — 语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids，索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（掩码），损失仅计算在[0, ..., config.vocab_size]中的标签。

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False，则根据配置（ImageGPTConfig）和输入包含各种元素。

loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
logits (torch.FloatTensor的形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 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, sequence_length, sequence_length)。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。
在注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。

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

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

示例：

>>> from transformers import AutoImageProcessor, ImageGPTForCausalImageModeling
>>> import torch
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> image_processor = AutoImageProcessor.from_pretrained("openai/imagegpt-small")
>>> model = ImageGPTForCausalImageModeling.from_pretrained("openai/imagegpt-small")
>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
>>> model.to(device)
>>> # unconditional generation of 8 images
>>> batch_size = 4
>>> context = torch.full((batch_size, 1), model.config.vocab_size - 1)  # initialize with SOS token
>>> context = context.to(device)
>>> output = model.generate(
...     input_ids=context, max_length=model.config.n_positions + 1, temperature=1.0, do_sample=True, top_k=40
... )
>>> clusters = image_processor.clusters
>>> height = image_processor.size["height"]
>>> width = image_processor.size["width"]
>>> samples = output[:, 1:].cpu().detach().numpy()
>>> samples_img = [
...     np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [height, width, 3]).astype(np.uint8) for s in samples
... ]  # convert color cluster tokens back to pixels
>>> f, axes = plt.subplots(1, batch_size, dpi=300)
>>> for img, ax in zip(samples_img, axes):
...     ax.axis("off")
...     ax.imshow(img)

ImageGPTForImageClassification

`class transformers.ImageGPTForImageClassification`

<来源>

( config: ImageGPTConfig )

参数

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

ImageGPT 模型变压器顶部带有图像分类头（线性层）。ImageGPTForImageClassification 对隐藏状态进行平均池化以进行分类。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

`forward`

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs: Any ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。
如果使用past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。
可以使用 AutoImageProcessor 获取索引。有关详细信息，请参阅 ImageGPTImageProcessor.call()。
past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的past_key_values输出）。可用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经计算过。
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

1 表示未被masked的标记，
0 表示被masked的标记。

什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

0 对应于一个句子 A标记，
1 对应于一个句子 B标记。

什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：

1 表示头部未被masked，
0 表示头部被masked。

inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
如果使用了past_key_values，则可能只需输入最后的inputs_embeds（参见past_key_values）。
use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
labels（torch.LongTensor，形状为(batch_size,)，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

一个transformers.modeling_outputs.SequenceClassifierOutputWithPast或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（ImageGPTConfig）和输入的各种元素。

loss（torch.FloatTensor，形状为(1,)，可选，当提供labels时返回）— 分类（如果 config.num_labels==1 则为回归）损失。
logits（torch.FloatTensor，形状为(batch_size, config.num_labels)）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。
包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoImageProcessor, ImageGPTForImageClassification
>>> 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("openai/imagegpt-small")
>>> model = ImageGPTForImageClassification.from_pretrained("openai/imagegpt-small")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits

LeViT

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

概述

LeViT 模型是由 Ben Graham，Alaaeldin El-Nouby，Hugo Touvron，Pierre Stock，Armand Joulin，Hervé Jégou，Matthijs Douze 在LeViT: Introducing Convolutions to Vision Transformers中提出的。LeViT 通过一些架构上的差异来提高视觉 Transformer（ViT）的性能和效率，例如在 Transformer 中使用分辨率递减的激活图以及引入注意偏置以整合位置信息。

论文摘要如下：

我们设计了一系列图像分类架构，优化了在高速环境中准确性和效率之间的权衡。我们的工作利用了最近在基于注意力的架构中的发现，这些架构在高度并行处理硬件上具有竞争力。我们重新审视了卷积神经网络的广泛文献中的原则，将它们应用于 Transformer，特别是使用分辨率递减的激活图。我们还引入了注意偏置，一种将位置信息整合到视觉 Transformer 中的新方法。因此，我们提出了 LeVIT：一个用于快速推理图像分类的混合神经网络。我们考虑在不同硬件平台上的不同效率措施，以最好地反映各种应用场景。我们的广泛实验证明了我们的技术选择，并表明它们适用于大多数架构。总体而言，LeViT 在速度/准确性权衡方面明显优于现有的卷积网络和视觉 Transformer。例如，在 80%的 ImageNet top-1 准确率下，LeViT 比 EfficientNet 在 CPU 上快 5 倍。

LeViT 架构。摘自原始论文。

这个模型由anugunj贡献。原始代码可以在这里找到。

使用提示

与 ViT 相比，LeViT 模型使用额外的蒸馏头来有效地从教师（在 LeViT 论文中是类似 ResNet 的模型）中学习。蒸馏头通过在类似 ResNet 的模型的监督下进行反向传播来学习。他们还从卷积神经网络中汲取灵感，使用分辨率递减的激活图来提高效率。
对于精炼模型，有两种微调方法，要么（1）以经典方式，只在最终隐藏状态的顶部放置一个预测头，不使用蒸馏头，要么（2）在最终隐藏状态的顶部放置预测头和蒸馏头。在这种情况下，预测头使用正常的交叉熵训练，预测头和地面真实标签之间的交叉熵，而蒸馏预测头使用硬蒸馏（蒸馏头的预测和教师预测的标签之间的交叉熵）。在推理时，将两个头之间的平均预测作为最终预测。（2）也被称为“蒸馏微调”，因为依赖于已经在下游数据集上进行了微调的教师。在模型方面，（1）对应于 LevitForImageClassification，（2）对应于 LevitForImageClassificationWithTeacher。
所有发布的检查点都是在 ImageNet-1k 上进行了预训练和微调（也称为 ILSVRC 2012，包含 130 万张图像和 1,000 个类别）。没有使用外部数据。这与原始的 ViT 模型相反，后者在预训练中使用了外部数据，如 JFT-300M 数据集/Imagenet-21k。
LeViT 的作者发布了 5 个经过训练的 LeViT 模型，您可以直接插入 LevitModel 或 LevitForImageClassification。为了模拟在更大数据集上训练（仅使用 ImageNet-1k 进行预训练），使用了数据增强、优化和正则化等技术。可用的 5 个变体是（都在大小为 224x224 的图像上训练）：facebook/levit-128S、facebook/levit-128、facebook/levit-192、facebook/levit-256 和 facebook/levit-384。请注意，应该使用 LevitImageProcessor 来准备模型的图像。
LevitForImageClassificationWithTeacher 目前仅支持推理，不支持训练或微调。
您可以查看关于推理以及在自定义数据上进行微调的演示笔记本这里（您只需将 ViTFeatureExtractor 替换为 LevitImageProcessor，并将 ViTForImageClassification 替换为 LevitForImageClassification 或 LevitForImageClassificationWithTeacher）。

资源

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

图像分类

LevitForImageClassification 受到这个示例脚本和笔记本的支持。
参见：图像分类任务指南

如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审查！资源应该展示一些新东西，而不是重复现有资源。

LevitConfig

`class transformers.LevitConfig`

< source >

( image_size = 224 num_channels = 3 kernel_size = 3 stride = 2 padding = 1 patch_size = 16 hidden_sizes = [128, 256, 384] num_attention_heads = [4, 8, 12] depths = [4, 4, 4] key_dim = [16, 16, 16] drop_path_rate = 0 mlp_ratio = [2, 2, 2] attention_ratio = [2, 2, 2] initializer_range = 0.02 **kwargs )

参数

image_size (int, optional, defaults to 224) — 输入图像的大小。
num_channels (int, optional, defaults to 3) — 输入图像中的通道数。
kernel_size (int, optional, defaults to 3) — 补丁嵌入的初始卷积层的内核大小。
stride (int, optional, defaults to 2) — 补丁嵌入的初始卷积层的步幅大小。
padding (int, optional, defaults to 1) — 补丁嵌入的初始卷积层的填充大小。
patch_size (int, optional, defaults to 16) — 嵌入的补丁大小。
hidden_sizes (List[int], optional, defaults to [128, 256, 384]) — 每个编码器块的维度。
num_attention_heads (List[int], 可选, 默认为 [4, 8, 12]) — Transformer 编码器每个块中每个注意力层的注意力头数。
depths (List[int], 可选, 默认为 [4, 4, 4]) — 每个编码器块中的层数。
key_dim (List[int], 可选, 默认为 [16, 16, 16]) — 每个编码器块中键的大小。
drop_path_rate (int, 可选, 默认为 0) — 用于随机深度的丢弃概率，用于 Transformer 编码器块中的块。
mlp_ratios (List[int], 可选, 默认为 [2, 2, 2]) — 编码器块中 Mix FFNs 的隐藏层大小与输入层大小的比率。
attention_ratios (List[int], 可选, 默认为 [2, 2, 2]) — 注意力层的输出维度与输入维度的比率。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

这是一个配置类，用于存储 LevitModel 的配置。根据指定的参数实例化一个 LeViT 模型，定义模型架构。使用默认值实例化配置将产生类似于 LeViT facebook/levit-128S架构的配置。

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

示例:

>>> from transformers import LevitConfig, LevitModel
>>> # Initializing a LeViT levit-128S style configuration
>>> configuration = LevitConfig()
>>> # Initializing a model (with random weights) from the levit-128S style configuration
>>> model = LevitModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

LevitFeatureExtractor

`class transformers.LevitFeatureExtractor`

<来源>

( *args **kwargs )

`call`

<来源>

( images **kwargs )

预处理图像或一批图像。

LevitImageProcessor

`class transformers.LevitImageProcessor`

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = [0.485, 0.456, 0.406] image_std: Union = [0.229, 0.224, 0.225] **kwargs )

参数

do_resize (bool, 可选, 默认为 True) — 是否将输入的最短边调整为 int(256/224 *size)。可以被preprocess方法中的do_resize参数覆盖。
size (Dict[str, int], 可选, 默认为 {"shortest_edge" -- 224}): 调整大小后的输出图像大小。如果 size 是一个带有“width”和“height”键的字典，则图像将被调整为(size["height"], size["width"])。如果 size 是一个带有“shortest_edge”键的字典，则最短边值c将被重新缩放为int(c * (256/224))。图像的较小边将匹配到这个值，即如果高度>宽度，则图像将被重新缩放为(size["shortest_egde"] * height / width, size["shortest_egde"])。可以被preprocess方法中的size参数覆盖。
resample (PILImageResampling, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小，则要使用的重采样滤镜。可以被preprocess方法中的resample参数覆盖。
do_center_crop (bool, 可选, 默认为 True) — 是否对输入进行中心裁剪为(crop_size["height"], crop_size["width"])。可以被preprocess方法中的do_center_crop参数覆盖。
crop_size (Dict, 可选, 默认为 {"height" -- 224, "width": 224}): center_crop后的期望图像大小。可以被preprocess方法中的crop_size参数覆盖。
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（List[int]，可选，默认为[0.485, 0.456, 0.406]）— 如果要归一化图像，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。
image_std（List[int]，可选，默认为[0.229, 0.224, 0.225]）— 如果要归一化图像，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。

构建一个 LeViT 图像处理器。

`preprocess`

<来源>

( images: Union do_resize: Optional = None size: Optional = None resample: Resampling = None do_center_crop: Optional = None crop_size: Optional = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None return_tensors: Optional = 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）— 调整大小后的输出图像大小。如果大小是一个带有“宽度”和“高度”键的字典，则图像将被调整为（高度，宽度）。如果大小是一个带有“最短边”键的字典，则最短边值c将被重新缩放为 int（c （256/224））。图像的较小边将与此值匹配，即，如果高度>宽度，则图像将被重新缩放为（大小高度/宽度，大小）。
resample（PILImageResampling，可选，默认为PILImageResampling.BICUBIC）— 调整图像大小时要使用的重采样滤波器。
do_center_crop（bool，可选，默认为self.do_center_crop）— 是否对图像进行中心裁剪。
crop_size（Dict[str, int]，可选，默认为self.crop_size）— 中心裁剪后的输出图像大小。将图像裁剪为（crop_size[“height”]，crop_size[“width”]）。
do_rescale（bool，可选，默认为self.do_rescale）— 是否通过指定的比例rescale_factor重新缩放图像像素值-通常为 0 到 1 之间的值。
rescale_factor（float，可选，默认为self.rescale_factor）— 用于重新缩放图像像素值的因子。
do_normalize（bool，可选，默认为self.do_normalize）— 是否通过image_mean和image_std对图像像素值进行归一化。
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（str或ChannelDimension，可选，默认为ChannelDimension.FIRST）— 输出图像的通道维度格式。如果未设置，则使用输入图像的通道维度格式。可以是以下之一：

"channels_first"或ChannelDimension.FIRST：图像以(num_channels, height, width)格式。
"channels_last"或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)格式。

对图像或图像批次进行预处理，以用作 LeViT 模型的输入。

LevitModel

`class transformers.LevitModel`

<来源>

( config )

参数

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

裸的 Levit 模型输出原始特征，没有任何特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

`forward`

<来源>

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

参数

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

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

一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含各种元素，具体取决于配置（LevitConfig）和输入。

last_hidden_state（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。
pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）— 在空间维度上进行池化操作后的最后一层隐藏状态。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出和每一层的输出）。
模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

LevitModel 前向方法，覆盖__call__特殊方法。

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

示例：

>>> from transformers import AutoImageProcessor, LevitModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/levit-128S")
>>> model = LevitModel.from_pretrained("facebook/levit-128S")
>>> 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, 16, 384]

Transformers 4.37 中文文档（六十八）（4）https://developer.aliyun.com/article/1564094

Transformers 4.37 中文文档（六十八）（3）

ImageGPTForCausalImageModeling

`class transformers.ImageGPTForCausalImageModeling`

`forward`

ImageGPTForImageClassification

`class transformers.ImageGPTForImageClassification`

`forward`

LeViT

概述

使用提示

资源

LevitConfig

`class transformers.LevitConfig`

LevitFeatureExtractor

`class transformers.LevitFeatureExtractor`

`call`

LevitImageProcessor

`class transformers.LevitImageProcessor`

`preprocess`

LevitModel

`class transformers.LevitModel`

`forward`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（六十八）（3）

ImageGPTForCausalImageModeling

class transformers.ImageGPTForCausalImageModeling

forward

ImageGPTForImageClassification

class transformers.ImageGPTForImageClassification

forward

LeViT

概述

使用提示

资源

LevitConfig

class transformers.LevitConfig

LevitFeatureExtractor

class transformers.LevitFeatureExtractor

__call__

LevitImageProcessor

class transformers.LevitImageProcessor

preprocess

LevitModel

class transformers.LevitModel

forward

热门文章

最新文章

相关课程

相关电子书

`class transformers.ImageGPTForCausalImageModeling`

`forward`

`class transformers.ImageGPTForImageClassification`

`forward`

`class transformers.LevitConfig`

`class transformers.LevitFeatureExtractor`

`call`

`class transformers.LevitImageProcessor`

`preprocess`

`class transformers.LevitModel`

`forward`