Transformer

( depths: List = [3, 2, 6, 4] hidden_sizes: List = [48, 96, 224, 448] downsamples: List = [True, True, True, True] dim: int = 448 key_dim: int = 32 attention_ratio: int = 4 resolution: int = 7 num_hidden_layers: int = 5 num_attention_heads: int = 8 mlp_expansion_ratio: int = 4 hidden_dropout_prob: float = 0.0 patch_size: int = 16 num_channels: int = 3 pool_size: int = 3 downsample_patch_size: int = 3 downsample_stride: int = 2 downsample_pad: int = 1 drop_path_rate: float = 0.0 num_meta3d_blocks: int = 1 distillation: bool = True use_layer_scale: bool = True layer_scale_init_value: float = 1e-05 hidden_act: str = 'gelu' initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 image_size: int = 224 batch_norm_eps: float = 1e-05 **kwargs )

参数

depths (int列表, 可选, 默认为 [3, 2, 6, 4]) — 每个阶段的深度。
hidden_sizes (int列表, 可选, 默认为 [48, 96, 224, 448]) — 每个阶段的维度。
downsamples (List(bool), 可选，默认为 [True, True, True, True]) — 在两个阶段之间是否下采样输入。
dim (int, 可选，默认为 448) — Meta3D 层中的通道数
key_dim (int, 可选，默认为 32) — meta3D 块中键的大小。
attention_ratio (int, 可选，默认为 4) — MSHA 块中查询和值维度与键维度的比例
resolution (int, 可选, 默认值 7) — 每个补丁的大小
num_hidden_layers (int, 可选, 默认值 5) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认值 8) — 在 3D MetaBlock 中每个注意力层的注意力头数。
mlp_expansion_ratio (int, 可选, 默认为 4) — MLP 隐藏维度大小与其输入维度大小的比例。
hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入和解码器中的所有全连接层的 dropout 概率。
patch_size (int, 可选, 默认为 16) — 每个补丁的大小（分辨率）。
num_channels (int, 可选, 默认为 3) — 输入通道的数量。
pool_size (int, 可选，默认为 3) — 池化层的内核大小。
downsample_patch_size (int, 可选，默认为 3) — 下采样层中的补丁大小。
downsample_stride (int, 可选，默认为 2) — 下采样层中卷积内核的步长。
downsample_pad (int, 可选，默认为 1) — 下采样层中的填充。
drop_path_rate (int, 可选，默认为 0) — 在 DropPath 中增加 dropout几率的比率。
num_meta3d_blocks (int, 可选，默认为 1) — 最后阶段的 3D MetaBlocks 数量。
distillation (bool, 可选，默认为 True) — 是否添加蒸馏头。
use_layer_scale (bool, 可选，默认为 True) — 是否缩放 token 混合器的输出。
layer_scale_init_value (浮点数, 可选，默认为1e-5) — 分词混合器输出的缩放因子。
hidden_act (字符串或函数，可选，默认为 "gelu") — 编码器和解码器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new"。
initializer_range (浮点数, 可选，默认为0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (浮点数, 可选，默认为1e-12) — 层归一化层中使用的epsilon。
image_size (int, 可选, 默认为 224) — 每个图像的大小（分辨率）。

这是存储EfficientFormer模型配置的配置类。它用于根据指定的参数实例化EfficientFormer模型，定义模型架构。使用默认值实例化配置将产生类似于EfficientFormer snap-research/efficientformer-l1架构的配置。

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

示例

>>> from transformers import EfficientFormerConfig, EfficientFormerModel

>>> # Initializing a EfficientFormer efficientformer-l1 style configuration
>>> configuration = EfficientFormerConfig()

>>> # Initializing a EfficientFormerModel (with random weights) from the efficientformer-l3 style configuration
>>> model = EfficientFormerModel(configuration)

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

EfficientFormerImageProcessor

class transformers.EfficientFormerImageProcessor

( do_resize: 布尔类型 = True size: 可选 = None resample: 重采样 = <重采样.BICUBIC: 3> do_center_crop: 布尔类型 = True do_rescale: 布尔类型 = True rescale_factor: 联合 = 0.00392156862745098 crop_size: 字典 = None do_normalize: 布尔类型 = True image_mean: 联合 = None image_std: 联合 = None **kwargs )

参数

do_resize (布尔类型, 可选, 默认为 True) — 是否将图像的大小调整（高度，宽度）到指定的 (size["height"], size["width"])。可以通过 preprocess 方法中的 do_resize 参数覆盖。
size (字典, 可选, 默认为 {"height" -- 224, "width": 224}): 图像重置后的大小。可以通过 preprocess 方法中的 size 参数覆盖。
resample (PILImageResampling，可选，默认为PILImageResampling.BILINEAR） — 如果调整图像大小时使用的重采样过滤器。可以在preprocess方法中的resample参数中覆盖。
do_center_crop (bool，可选，默认为True） — 是否将图像中心裁剪到指定的crop_size。可以在preprocess方法中的do_center_crop中覆盖。
crop_size (Dict[str, int]，可选，默认为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 — 是否对图像进行归一化。可以被 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 参数覆盖。

构建一个EfficientFormer图像处理器。

预处理

参数

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_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否居中裁剪图像。
do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放到 [0 - 1] 范围内。
rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的系数。
crop_size （Dict[str, int]，可选，默认为self.crop_size） — 中心裁剪的尺寸。只有当do_center_crop设置为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：图像格式为 (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)。

预处理图像或图像批次。

Pytorch

隐藏 Pytorch 内容

EfficientFormerModel

类 transformers.EfficientFormerModel

( config: EfficientFormerConfig )

参数

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

无特定头部课程的EfficientFormer模型，输出生成的原始隐藏状态。此模型为PyTorch nn.Module 子类。将其用作常规PyTorch模块，并参照PyTorch文档了解有关一般使用和行为的所有事宜。

向前传播

( pixel_values: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor 形状 (batch_size, num_channels, height, width)) — 像素值。可以使用 ViTImageProcessor 获取像素值。请参阅 ViTImageProcessor.preprocess() 获取详情。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。请参阅返回张量下的 attentions 获取更多详情。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。请参阅返回张量下的 hidden_states 获取更多详情。
return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回值

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个由 torch.FloatTensor 组成的元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），包含根据配置（《EfficientFormerConfig》）和输入的不同而不同的各种元素。

last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor 形状为 (batch_size, hidden_size)) — 序列中第一个词（分类词）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后。例如，对于BERT系列的模型，这返回分类词经过线性层和tanh激活函数处理后的结果。线性层的权重在预训练期间从下一个句子预测（分类）目标中训练出来。
hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 时返回，或者当 config.output_hidden_states=True 时返回) — 包含 torch.FloatTensor 的元组（如果有嵌入层，则为嵌入输出的输出，然后是每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型的每层输出隐藏状态，以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，在传递 output_attentions=True 时返回，或者当 config.output_attentions=True 时返回) — 包含 torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

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

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

示例

>>> from transformers import AutoImageProcessor, EfficientFormerModel
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = EfficientFormerModel.from_pretrained("snap-research/efficientformer-l1-300")

>>> 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, 49, 448]

EfficientFormerForImageClassification

类 transformers.EfficientFormerForImageClassification

( config: EfficientFormerConfig )

参数

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

EfficientFormer 模型，顶上具有图像分类头（位于[CLS]标记的最终隐藏状态之上的线性层），例如用于 ImageNet。

该模型是 PyTorch nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取所有相关于通用使用和行为的内容。

向前传播

( pixel_values: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 ViTImageProcessor 获取。有关详细信息，请参阅 ViTImageProcessor.preprocess()。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。详见返回张量下的 attentions 的更多详细信息。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。详见返回张量下的 hidden_states 的更多详细信息。
return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是原始元组。
labels (torch.LongTensor of shape (batch_size,), 可选) — 计算图像分类/回归损失的标签。索引应在 [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），包含各种元素，具体取决于配置（EfficientFormerConfig）和输入。

loss (torch.FloatTensor of shape (1,), 可选，当提供 labels 时返回) — 分类（或当 config.num_labels == 1 时的回归）损失。
logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（或当 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的注意力权重，用于在自注意力头中计算加权平均值。

EfficientFormerForImageClassification 的前进方法，覆盖了特殊的 __call__ 方法。

示例

>>> from transformers import AutoImageProcessor, EfficientFormerForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300")

>>> 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])
Egyptian cat

EfficientFormerForImageClassificationWithTeacher

class transformers.EfficientFormerForImageClassificationWithTeacher

( config: EfficientFormerConfig )

参数

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

EfficientFormer 模型变压器，顶部带有图像分类头（在[CLS]标记的最后隐藏状态上方的线性层以及在蒸馏标记的最后隐藏状态上方的线性层），例如用于ImageNet。

此模型支持仅推理。带蒸馏（即与教师一起）的微调尚不支持。

该模型是 PyTorch nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取所有相关于通用使用和行为的内容。

向前传播

( pixel_values: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.models.deprecated.efficientformer.modeling_efficientformer.EfficientFormerForImageClassificationWithTeacherOutput 或 tuple(torch.FloatTensor)

参数

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

返回值

transformers.models.deprecated.efficientformer.modeling_efficientformer.EfficientFormerForImageClassificationWithTeacherOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.deprecated.efficientformer.modeling_efficientformer.EfficientFormerForImageClassificationWithTeacherOutput 或一个包含多种元素的tuple，其中的元素取决于配置（EfficientFormerConfig）和输入（如果传入 return_dict=False 或当 config.return_dict=False）。

logits （shape为 (batch_size, config.num_labels) 的 torch.FloatTensor）— cls_logits 和蒸馏logits的平均预估计得分。
cls_logits （shape为 (batch_size, config.num_labels) 的 torch.FloatTensor）— 分类头（即 Class token 的最后隐藏状态顶部的线性层）的预测得分。
distillation_logits （shape为 (batch_size, config.num_labels) 的 torch.FloatTensor）— 蒸馏头（即 Distillation token 的最后隐藏状态顶部的线性层）的预测得分。
hidden_states （shape为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 的tuple，可选，返回当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时）— tuple包含嵌入输出和每层输出。
attentions （shape为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 的tuple，可选，返回当传入 output_attentions=True 或当 config.output_attentions=True 时）— 包含每个层的注意力权重。

《EfficientFormerForImageClassificationWithTeacher》的前向方法重写了__call__特殊方法。

示例

>>> from transformers import AutoImageProcessor, EfficientFormerForImageClassificationWithTeacher
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = EfficientFormerForImageClassificationWithTeacher.from_pretrained("snap-research/efficientformer-l1-300")

>>> 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])
Egyptian cat

TensorFlow

隐藏TensorFlow内容

TFEfficientFormerModel

类 transformers.TFEfficientFormerModel

( config: EfficientFormerConfig **kwargs )

参数

config (EfficientFormerConfig）—一个包含模型所有参数的模型配置类。使用配置文件初始化时，不加载模型的权重，只有配置。请查看from_pretrained()方法来加载模型权重。

裸EfficientFormer模型，输出原始隐藏状态而不在任何特定头部的模型。这是一个TensorFlow keras(layers.Layer)。将其用作常规TensorFlow模块，并参考TensorFlow文档以了解所有与通用使用和行为相关的信息。

调用

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

pixel_values （形状为(batch_size, num_channels, height, width)的tf.Tensor — 像素值。像素值可以通过使用AutoImageProcessor获得。详细信息请参阅EfficientFormerImageProcessor.call()。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关返回张量下的更多详细信息，请参见 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关返回张量下的更多详细信息，请参见 hidden_states。
return_dict (bool, optional) — 是否用 ModelOutput 替代普通元组。

返回值

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

根据配置（《EfficientFormerConfig》）和输入返回一个 `transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling` 或由 tf.Tensor 构成的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）。

last_hidden_state (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output（tf.Tensor形状为(batch_size, hidden_size)）—— 首个标记（分类标记）的最后一层隐藏状态经过线性层和Tanh激活函数进一步处理。线性层的权重是在预训练期间从下一句预测（分类）目标中训练得到的。

此输出通常不是输入语义内容的良好摘要，您通常会通过平均或池化整个输入序列的隐藏状态序列而获得更好的结果。
hidden_states（tuple(tf.Tensor)，可选，当传递参数output_hidden_states=True或当配置参数config.output_hidden_states=True时返回）—— 一个形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入层的输出，一个用于每一层的输出）。

每层输出以及初始嵌入输出的模型隐藏状态。
attentions（tuple(tf.Tensor)，可选，当传递参数output_attentions=True或当配置参数config.output_attentions=True时返回）—— 每一层的形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。

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

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

示例

>>> from transformers import AutoImageProcessor, TFEfficientFormerModel
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = TFEfficientFormerModel.from_pretrained("snap-research/efficientformer-l1-300")

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

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 49, 448]

TFEfficientFormerForImageClassification

类 transformers.TFEfficientFormerForImageClassification

( config: EfficientFormerConfig )

参数

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

EfficientFormer 模型是具有图像分类头部的 Transformer 模型，位于池化后的最后一个隐藏状态之上，例如用于 ImageNet。

此模型是 TensorFlow keras.layers.Layer。将其用作常规 TensorFlow 模块，并参考 TensorFlow 文档以获取所有与通用使用和行为相关的事项。

调用

( pixel_values: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None training: bool = False ) → transformers.modeling_tf_outputs.TFImageClassifierOutput 或 tuple(tf.Tensor)

参数

pixel_values （tf.Tensor 形状为 (batch_size, num_channels, height, width)）— 像素值。可以通过 AutoImageProcessor 获取像素值。有关详细信息，请参阅 EfficientFormerImageProcessor.call()。
output_attentions （bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states （bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回ModelOutput，而不是普通元组。
labels (tf.Tensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

transformers.modeling_tf_outputs.TFImageClassifierOutput或一个tf.Tensor的元组（如果传递了return_dict=False或当config.return_dict=False），包含根据配置（《EfficientFormerConfig》）和输入的不同元素。

loss（《tf.Tensor，形状为(1,)，可选，当提供`labels`时返回） — 分类（如果`config.num_labels==1`则为回归）损失。
logits（《tf.Tensor，形状为(batch_size, config.num_labels)） — 分类（如果`config.num_labels==1`则为回归）得分（在SoftMax之前）。
hidden_states（《tuple(tf.Tensor)》，可选，当传递`output_hidden_states=True`时返回，或当`config.output_hidden_states=True`时返回） — 元组，包含tf.Tensor（如果有嵌入层，则为嵌入层的输出+每个阶段的输出）的形状为(batch_size, sequence_length, hidden_size)。这是在每个阶段的模型输出处的隐藏状态（也称为特征图）。
attentions（《tuple(tf.Tensor)》，可选，当传递`output_attentions=True`时返回，或当`config.output_attentions=True`时返回） — 元组，包含tf.Tensor（每个层一个）的形状为(batch_size, num_heads, patch_size, sequence_length)。

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

TFEfficientFormerForImageClassification的forward方法覆盖了__call__特殊方法。

示例

>>> from transformers import AutoImageProcessor, TFEfficientFormerForImageClassification
>>> import tensorflow as tf
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
>>> model = TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300")

>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
LABEL_281

TFEfficientFormerForImageClassificationWithTeacher

类 transformers.TFEfficientFormerForImageClassificationWithTeacher

< 源 >

( config: EfficientFormerConfig )

参数

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

EfficientFormer 模型，带有图像分类头部的转换器（最终隐藏状态和精馏标记的最终隐藏状态之上的线性层），例如用于 ImageNet。

.. 警告:: 此模型仅支持推理。使用精馏（即使用教师）进行微调目前不受支持。

此模型是 TensorFlow keras.layers.Layer。将其用作常规 TensorFlow 模块，并参考 TensorFlow 文档以获取所有与通用使用和行为相关的事项。

调用