Transformers documentation
卷积视觉 Transformer (CvT)
该模型于 2021-03-29 在 HF papers 上发布，并于 2022-05-18 贡献至 Hugging Face Transformers。
卷积视觉 Transformer (CvT)
卷积视觉 Transformer（CvT） 是一种结合卷积神经网络（CNN）和视觉 Transformer 优势的模型，用于计算机视觉任务。它在视觉 Transformer 架构中引入了卷积层，使其能够在保持自注意力机制提供的全局上下文的同时，捕获图像中的局部模式。
您可以在 Microsoft 组织下找到所有 CvT 检查点。
该模型由 anujunj 贡献。
点击右侧边栏中的 CvT 模型，以查看将 CvT 应用于不同计算机视觉任务的更多示例。
下面的示例演示了如何使用 Pipeline 或 AutoModel 类对图像进行分类。
from transformers import pipeline
pipeline = pipeline(
task="image-classification",
model="microsoft/cvt-13",
device=0
)
pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")import requests
import torch
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForImageClassification
image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
model = AutoModelForImageClassification.from_pretrained(
"microsoft/cvt-13",
device_map="auto"
)
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = image_processor(image, return_tensors="pt").to(model.device)
with torch.no_grad():
logits = model(**inputs).logits
predicted_class_id = logits.argmax(dim=-1).item()
class_labels = model.config.id2label
predicted_class_label = class_labels[predicted_class_id]
print(f"The predicted class label is: {predicted_class_label}")资源
请参阅这组 ViT notebooks，其中包含在自定义数据集上进行推理和微调的示例。在这些 notebooks 中，将 ViTFeatureExtractor 和 ViTForImageClassification 替换为 AutoImageProcessor 和 CvtForImageClassification。
CvtConfig
class transformers.CvtConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_channels: int = 3patch_sizes: list[int] | tuple[int, ...] = (7, 3, 3)patch_stride: list[int] | tuple[int, ...] = (4, 2, 2)patch_padding: list[int] | tuple[int, ...] = (2, 1, 1)embed_dim: list[int] | tuple[int, ...] = (64, 192, 384)num_heads: list[int] | tuple[int, ...] = (1, 3, 6)depth: list[int] | tuple[int, ...] = (1, 2, 10)mlp_ratio: list[float] | tuple[float, ...] = (4.0, 4.0, 4.0)attention_drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0)drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0)drop_path_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.1)qkv_bias: list[bool] | tuple[bool, ...] = (True, True, True)cls_token: list[bool] | tuple[bool, ...] = (False, False, True)qkv_projection_method: list[str] | tuple[str, ...] = ('dw_bn', 'dw_bn', 'dw_bn')kernel_qkv: list[int] | tuple[int, ...] = (3, 3, 3)padding_kv: list[int] | tuple[int, ...] = (1, 1, 1)stride_kv: list[int] | tuple[int, ...] = (2, 2, 2)padding_q: list[int] | tuple[int, ...] = (1, 1, 1)stride_q: list[int] | tuple[int, ...] = (1, 1, 1)initializer_range: float = 0.02layer_norm_eps: float = 1e-12 )
参数
- num_channels (
int，可选，默认为3) — 输入通道的数量。 - patch_sizes (
Union[list[int], tuple[int, ...]]，可选，默认为(7, 3, 3)) — 模型各阶段的 Patch 大小。 - patch_stride (
list[int]，可选，默认为[4, 2, 2]) — 每个编码器 patch 嵌入的步长大小。 - patch_padding (
list[int]，可选，默认为[2, 1, 1]) — 每个编码器 patch 嵌入的填充大小。 - embed_dim (
Union[list[int], tuple[int, ...]]，可选，默认为(64, 192, 384)) — 嵌入和隐藏状态的维度。 - num_heads (
Union[list[int], tuple[int, ...]]，可选，默认为(1, 3, 6)) — Transformer 解码器中每个注意力层的注意力头数量。 - depth (
list[int]，可选，默认为[1, 2, 10]) — 每个编码器块中的层数。 - mlp_ratio (
Union[list[float], tuple[float, ...]]，可选，默认为(4.0, 4.0, 4.0)) — MLP 隐藏层维度与嵌入维度的比例。 - attention_drop_rate (
list[float]，可选，默认为[0.0, 0.0, 0.0]) — 注意力概率的 dropout 比率。 - drop_rate (
list[float]，可选，默认为[0.0, 0.0, 0.0]) — 用于 patch embeddings 概率的 dropout 比率。 - drop_path_rate (
Union[list[float], tuple[float, ...]]，可选，默认为(0.0, 0.0, 0.1)) — 用于 patch 融合的 drop path 比率。 - qkv_bias (
Union[list[bool], tuple[bool, ...]]，可选，默认为(True, True, True)) — 是否为查询（queries）、键（keys）和值（values）添加偏置。 - cls_token (
list[bool]，可选，默认为[False, False, True]) — 是否在每个最后 3 个阶段的输出中添加分类标记。 - qkv_projection_method (
list[string], 可选, 默认值为 [“dw_bn”, “dw_bn”, “dw_bn”]`) — 用于 query、key 和 value 的投影方法。默认使用带 batch norm 的深度可分离卷积。若使用 Linear 投影，请传入 “avg”。 - kernel_qkv (
list[int]，可选，默认为[3, 3, 3]) — 注意力层中 query、key 和 value 的卷积核大小 - padding_kv (
list[int]，可选，默认为[1, 1, 1]) — 注意力层中 key 和 value 的填充大小 - stride_kv (
list[int]，可选，默认为[2, 2, 2]) — 注意力层中 key 和 value 的步长大小 - padding_q (
list[int]，可选，默认为[1, 1, 1]) — 注意力层中查询的填充大小 - stride_q (
list[int]，可选，默认为[1, 1, 1]) — 注意力层中查询的步长大小 - initializer_range (
float，可选，默认为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float，可选，默认为1e-12) — 层归一化层所使用的 epsilon 值。
这是用于存储 CvtModel 配置的类。它根据指定的参数实例化 Cvt 模型，并定义模型架构。使用默认值实例化配置将得到与 microsoft/cvt-13 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> from transformers import CvtConfig, CvtModel
>>> # Initializing a Cvt msft/cvt style configuration
>>> configuration = CvtConfig()
>>> # Initializing a model (with random weights) from the msft/cvt style configuration
>>> model = CvtModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configCvtModel
类 transformers.CvtModel
< source >( config: CvtConfigadd_pooling_layer = True )
参数
- config (CvtConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- add_pooling_layer (
bool，可选，默认为True) — 是否添加池化层
裸 Cvt 模型，直接输出原始 hidden-states，顶部不附加任何特定 head。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithCLSToken or tuple(torch.Tensor)
参数
- pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 ConvNextImageProcessor 获取像素值。有关详细信息，请参阅 ConvNextImageProcessor.call()（processor_class使用 ConvNextImageProcessor 处理图像）。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
BaseModelOutputWithCLSToken 或 tuple(torch.Tensor)
BaseModelOutputWithCLSToken 或 torch.Tensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（CvtConfig）和输入。
CvtModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选）— 模型最后一层输出的隐藏状态序列。cls_token_value（形状为
(batch_size, 1, hidden_size)的torch.Tensor）— 模型最后一层输出的分类标记。hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
CvtForImageClassification
class transformers.CvtForImageClassification
< source >( config: CvtConfig )
参数
- config (CvtConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Cvt 模型，顶部带有图像分类头（在 [CLS] token 的最终隐藏状态之上添加一个线性层），例如用于 ImageNet。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ImageClassifierOutputWithNoAttention or tuple(torch.Tensor)
参数
- pixel_values (
torch.Tensor，形状为(batch_size, num_channels, image_size, image_size)，可选) — 与输入图像对应的张量。可以使用 ConvNextImageProcessor 获取像素值。有关详细信息，请参阅 ConvNextImageProcessor.call()（processor_class使用 ConvNextImageProcessor 处理图像）。 - labels（形状为
(batch_size,)的torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
ImageClassifierOutputWithNoAttention 或 tuple(torch.Tensor)
一个 ImageClassifierOutputWithNoAttention 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（CvtConfig）和输入。
CvtForImageClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
- loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。 - hidden_states (
tuple(torch.Tensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个阶段输出的一个张量），形状为(batch_size, num_channels, height, width)。模型在每个阶段输出处的隐藏状态（也称为特征图）。
示例：
>>> from transformers import AutoImageProcessor, CvtForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtForImageClassification.from_pretrained("microsoft/cvt-13")
>>> 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])
...