Transformers documentation

TimmWrapper

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

TimmWrapper

概述

辅助类，用于加载 timm 模型，以便与 transformers 库及其自动类配合使用。

from urllib.request import urlopen

import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForImageClassification


# Load image
image = Image.open(urlopen(
    'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
))

# Load model and image processor
checkpoint = "timm/resnet50.a1_in1k"
image_processor = AutoImageProcessor.from_pretrained(checkpoint)
model = AutoModelForImageClassification.from_pretrained(checkpoint).eval( device_map="auto")

# Preprocess image
inputs = image_processor(image)

# Forward pass
with torch.no_grad():
    logits = model(**inputs).logits

# Get top 5 predictions
top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)

资源

以下是来自 Hugging Face 官方和社区（以 🌎 标识）的资源列表，可帮助您快速上手 TimmWrapper。

Image Classification

示例 Notebook 合集 🌎

如需更详细的概述，请阅读关于 timm 集成的官方博客文章。

TimmWrapperConfig

class transformers.TimmWrapperConfig

< 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 = Nonearchitecture: str = 'resnet50'initializer_range: float = 0.02do_pooling: bool = Truemodel_args: dict[str, typing.Any] | None = None )

参数

architecture (str，可选，默认为 "resnet50") — 要加载的 timm 架构。
initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
do_pooling (bool，可选，默认为 True) — 是否对 TimmWrapperModel 中的 last_hidden_state 执行池化。
model_args (dict[str, Any], 可选) — 传递给 timm.create_model 函数的额外关键字参数。例如，对于 timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k，使用 model_args={"depth": 3} 可以创建一个包含 3 个 block 的模型。默认值为 None。

这是用于存储 TimmWrapperModel 配置的类。它根据指定的参数实例化 Timm Wrapper 模型，并定义模型架构。使用默认值实例化配置将得到与 resnet50 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

>>> from transformers import TimmWrapperModel

>>> # Initializing a timm model
>>> model = TimmWrapperModel.from_pretrained("timm/resnet18.a1_in1k")

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

TimmWrapperImageProcessor

class transformers.TimmWrapperImageProcessor

< source >

( pretrained_cfg: dictarchitecture: str | None = None**kwargs )

参数

pretrained_cfg (dict[str, Any]) — 用于解析评估和训练转换的预训练模型配置。
architecture (Optional[str], 可选) — 模型的架构名称。

用于在 transformers 中使用的 timm 模型的包装类。

预处理

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]return_tensors: str | transformers.utils.generic.TensorType | None = 'pt' )

参数

images (ImageInput) — 要预处理的图像。期望输入单张图像或一批图像
return_tensors（str 或 TensorType，可选）— 要返回的张量类型。

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

TimmWrapperModel

class transformers.TimmWrapperModel

< source >

( config: TimmWrapperConfig )

用于在 Transformers 中使用的 timm 模型的包装类。

forward

< source >

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)) — 与输入图像对应的张量。可以使用 TimmWrapperImageProcessor 获取像素值。有关详细信息，请参阅 TimmWrapperImageProcessor.call()（processor_class 使用 TimmWrapperImageProcessor 处理图像）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。与 timm 包装的模型不兼容。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。与 timm 包装的模型不兼容。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
do_pooling (bool, 可选) — 是否对 TimmWrapperModel 中的 last_hidden_state 执行池化。如果传入 None，则使用配置中的 do_pooling 值。
use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

返回值

TimmWrapperModelOutput 或 tuple(torch.Tensor)

TimmWrapperModelOutput 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（TimmWrapperConfig）和输入。

TimmWrapperModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

last_hidden_state (torch.Tensor) — 模型的最后一个隐藏状态，在应用分类头之前输出。
pooler_output (torch.Tensor，可选) — 如果适用，则是由最后一个隐藏状态得出的池化输出。
hidden_states (tuple(torch.Tensor)，可选，当设置 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个元组，包含模型在每一层或指定层输出处的中间隐藏状态。
attentions (tuple(torch.Tensor)，可选，当设置 output_attentions=True 或 config.output_attentions=True 时返回。) — 一个元组，包含模型每层输出的中间注意力权重。注意：目前，Timm 模型不支持输出 attentions。

示例：

>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModel, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModel.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Get pooled output
>>> pooled_output = outputs.pooler_output

>>> # Get last hidden state
>>> last_hidden_state = outputs.last_hidden_state

TimmWrapperForImageClassification

class transformers.TimmWrapperForImageClassification

< source >

( config: TimmWrapperConfig )

用于在 transformers 中进行图像分类的 timm 模型的包装类。

forward

< source >

( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | list[int] | None = Nonereturn_dict: bool | None = None**kwargs ) → ImageClassifierOutput or tuple(torch.Tensor)

参数

pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)) — 与输入图像对应的张量。可以使用 TimmWrapperImageProcessor 获取像素值。有关详细信息，请参阅 TimmWrapperImageProcessor.call()（processor_class 使用 TimmWrapperImageProcessor 处理图像）。
labels（形状为 (batch_size,) 的 torch.LongTensor，可选）— 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。与 timm 包装的模型不兼容。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。与 timm 包装的模型不兼容。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 **kwargs: 传递给 timm 模型 forward 的额外关键字参数。

返回值

ImageClassifierOutput 或 tuple(torch.Tensor)

一个 ImageClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（TimmWrapperConfig）和输入。

TimmWrapperForImageClassification 的 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, sequence_length, hidden_size)。模型在每个阶段输出处的隐藏状态（也称为特征图）。
attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, patch_size, sequence_length)。

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

示例：

>>> import torch
>>> from PIL import Image
>>> from urllib.request import urlopen
>>> from transformers import AutoModelForImageClassification, AutoImageProcessor

>>> # Load image
>>> image = Image.open(urlopen(
...     'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/beignets-task-guide.png'
... ))

>>> # Load model and image processor
>>> checkpoint = "timm/resnet50.a1_in1k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModelForImageClassification.from_pretrained(checkpoint).eval()

>>> # Preprocess image
>>> inputs = image_processor(image)

>>> # Forward pass
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # Get top 5 predictions
>>> top5_probabilities, top5_class_indices = torch.topk(logits.softmax(dim=1) * 100, k=5)

Update on GitHub

←TextNet UperNet→