Transformers 4.37 中文文档（六十七）（5）

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

EfficientNet

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/efficientnet

概述

EfficientNet 模型是由 Mingxing Tan 和 Quoc V. Le 在EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks中提出的。EfficientNets 是一系列图像分类模型，实现了最先进的准确性，同时比以前的模型小一个数量级且更快。

从论文中摘录的如下：

卷积神经网络（ConvNets）通常在固定的资源预算下开发，如果有更多资源可用，则会扩展以获得更好的准确性。在本文中，我们系统地研究了模型的缩放，并确定了仔细平衡网络深度、宽度和分辨率可以带来更好的性能。基于这一观察，我们提出了一种新的缩放方法，使用简单但非常有效的复合系数均匀缩放深度/宽度/分辨率的所有维度。我们展示了这种方法在扩展  MobileNets 和 ResNet 时的有效性。为了更进一步，我们使用神经架构搜索设计了一个新的基准网络，并将其扩展为一系列模型，称为  EfficientNets，这些模型在准确性和效率方面比以前的 ConvNets 要好得多。特别是，我们的 EfficientNet-B7 在  ImageNet 上实现了最先进的 84.3%的 top-1 准确性，同时比最佳现有 ConvNet 在推理时小 8.4 倍，快 6.1  倍。我们的 EfficientNets 也具有良好的迁移性能，并在 CIFAR-100（91.7%）、Flowers（98.8%）和其他 3  个迁移学习数据集上实现了最先进的准确性，参数数量少一个数量级。

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

EfficientNetConfig

class transformers.EfficientNetConfig

< source >

( num_channels: int = 3 image_size: int = 600 width_coefficient: float = 2.0 depth_coefficient: float = 3.1 depth_divisor: int = 8 kernel_sizes: List = [3, 3, 5, 3, 5, 5, 3] in_channels: List = [32, 16, 24, 40, 80, 112, 192] out_channels: List = [16, 24, 40, 80, 112, 192, 320] depthwise_padding: List = [] strides: List = [1, 2, 2, 2, 1, 2, 1] num_block_repeats: List = [1, 2, 2, 3, 3, 4, 1] expand_ratios: List = [1, 6, 6, 6, 6, 6, 6] squeeze_expansion_ratio: float = 0.25 hidden_act: str = 'swish' hidden_dim: int = 2560 pooling_type: str = 'mean' initializer_range: float = 0.02 batch_norm_eps: float = 0.001 batch_norm_momentum: float = 0.99 dropout_rate: float = 0.5 drop_connect_rate: float = 0.2 **kwargs )

参数

• num_channels (int, optional, 默认为 3) — 输入通道数。
  
• image_size (int, optional, 默认为 600) — 输入图像大小。
  
• width_coefficient (float, optional, 默认为 2.0) — 每个阶段网络宽度的缩放系数。
  
• depth_coefficient (float, optional, 默认为 3.1) — 每个阶段网络深度的缩放系数。
  
• depth_divisor int, optional, 默认为 8) — 网络宽度的一个单位。
  
• kernel_sizes (List[int], optional, 默认为 [3, 3, 5, 3, 5, 5, 3]) — 用于每个块的内核大小列表。
  
• in_channels (List[int], optional, 默认为 [32, 16, 24, 40, 80, 112, 192]) — 用于卷积层中每个块的输入通道大小列表。
  
• out_channels (List[int], optional, 默认为 [16, 24, 40, 80, 112, 192, 320]) — 用于卷积层中每个块的输出通道大小列表。
  
• depthwise_padding (List[int], optional, 默认为 []) — 具有方形填充的块索引列表。
  
• strides (List[int], optional, 默认为 [1, 2, 2, 2, 1, 2, 1]) — 用于卷积层中每个块的步幅大小列表。
  
• num_block_repeats (List[int], optional, 默认为 [1, 2, 2, 3, 3, 4, 1]) — 每个块重复的次数列表。
  
• expand_ratios (List[int], optional, 默认为 [1, 6, 6, 6, 6, 6, 6]) — 每个块的缩放系数列表。
  
• squeeze_expansion_ratio (float, optional, 默认为 0.25) — 挤压扩展比率。
  
• hidden_act (str 或 function, optional, 默认为 "silu") — 每个块中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"、"gelu_new"、"silu"和"mish"。
  
• hiddem_dim (int, optional, defaults to 1280) — 分类头之前的隐藏维度。
  
• pooling_type (str or function, optional, defaults to "mean") — 在密集分类头之前应用的最终池化类型。可用选项为["mean", "max"]
  
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• batch_norm_eps (float, optional, defaults to 1e-3) — 批量归一化层使用的 epsilon。
  
• batch_norm_momentum (float, optional, defaults to 0.99) — 批量归一化层使用的动量。
  
• dropout_rate (float, optional, defaults to 0.5) — 应用于最终分类器层之前的丢弃率。
  
• drop_connect_rate (float, optional, defaults to 0.2) — 跳跃连接的丢弃率。
  

这是用于存储 EfficientNetModel 配置的配置类。它用于根据指定的参数实例化一个 EfficientNet 模型，定义模型架构。使用默认值实例化配置将产生类似于 EfficientNet google/efficientnet-b7架构的配置。

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

示例：

>>> from transformers import EfficientNetConfig, EfficientNetModel
>>> # Initializing a EfficientNet efficientnet-b7 style configuration
>>> configuration = EfficientNetConfig()
>>> # Initializing a model (with random weights) from the efficientnet-b7 style configuration
>>> model = EfficientNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

EfficientNetImageProcessor

class transformers.EfficientNetImageProcessor

< source >

( do_resize: bool = True size: Dict = None resample: Resampling = 0 do_center_crop: bool = False crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 rescale_offset: bool = False do_rescale: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None include_top: bool = True **kwargs )

参数

• do_resize (bool, optional, defaults to True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess中的do_resize覆盖。
  
• size (Dict[str, int] optional, defaults to {"height" -- 346, "width": 346}): resize后的图像大小。可以被preprocess中的size覆盖。
  
• resample (PILImageResampling filter, optional, defaults to 0) — 如果调整图像大小，则使用的重采样滤波器。可以被preprocess中的resample覆盖。
  
• do_center_crop (bool, optional, defaults to False) — 是否中心裁剪图像。如果输入尺寸沿任何边小于crop_size，则图像将填充 0，然后进行中心裁剪。可以被preprocess中的do_center_crop覆盖。
  
• crop_size (Dict[str, int], optional, defaults to {"height" -- 289, "width": 289}): 应用中心裁剪时的期望输出大小。可以被preprocess中的crop_size覆盖。
  
• rescale_factor (int or float, optional, defaults to 1/255) — 如果重新调整图像，则使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。
  
• rescale_offset (bool, optional, defaults to False) — 是否将图像重新调整到[-scale_range, scale_range]而不是[0, scale_range]。可以被preprocess方法中的rescale_factor参数覆盖。
  
• do_rescale (bool, optional, defaults to True) — 是否按照指定的比例rescale_factor重新调整图像。可以被preprocess方法中的do_rescale参数覆盖。
  
• do_normalize (bool, optional, defaults to 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 参数覆盖。
  
• include_top (bool, 可选, 默认为 True) — 是否再次对图像进行重新缩放。如果输入用于图像分类，则应设置为 True。
  

构建一个 EfficientNet 图像处理器。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None rescale_offset: bool = None do_normalize: bool = None image_mean: Union = None image_std: Union = None include_top: bool = 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) — resize 后的图像大小。
  
• resample (PILImageResampling, 可选, 默认为 self.resample) — 调整图像大小时要使用的 PILImageResampling 过滤器。仅在 do_resize 设置为 True 时有效。
  
• do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
  
• crop_size (Dict[str, int], 可选, 默认为 self.crop_size) — 居中裁剪后的图像大小。如果图像的一条边小于 crop_size，则会用零填充，然后裁剪。
  
• do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否将图像值重新缩放在 [0 - 1] 之间。
  
• rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则重新缩放图像的重新缩放因子。
  
• rescale_offset (bool, 可选, 默认为 self.rescale_offset) — 是否将图像重新缩放在 [-scale_range, scale_range] 范围内，而不是 [0, scale_range]。
  
• do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  
• image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 图像均值。
  
• image_std (float 或 List[float], 可选, 默认为 self.image_std) — 图像标准差。
  
• include_top (bool, 可选, 默认为 self.include_top) — 如果设置为 True，则再次对图像进行图像分类的重新缩放。
  
• return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一：

• None: 返回一个 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: 图像格式为 (通道数, 高度, 宽度)。
  
• ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。
  

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

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

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

EfficientNetModel

class transformers.EfficientNetModel

<来源>

( config: EfficientNetConfig )

参数

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

裸的 EfficientNet 模型输出原始特征，没有特定的头部。这个模型是 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（torch.FloatTensor，形状为(batch_size, num_channels, height, width)）- 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅AutoImageProcessor.__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时）包含根据配置（EfficientNetConfig）和输入的各种元素。

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

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

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

示例：

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

EfficientNetForImageClassification

class transformers.EfficientNetForImageClassification

<来源>

( config )

参数

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

在顶部带有图像分类头部的 EfficientNet 模型（在池化特征的顶部有一个线性层），例如用于 ImageNet。

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

forward

<来源>

( pixel_values: FloatTensor = 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 (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。查看AutoImageProcessor.__call__()获取详细信息。
  
• 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.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)

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

• 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, num_channels, height, width)的torch.FloatTensor元组。模型在每个阶段输出的隐藏状态（也称为特征图）。
  

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

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

示例：

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

assifierOutputWithNoAttention or tuple(torch.FloatTensor)

参数
+   `pixel_values` (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`) — 像素值。可以使用 AutoImageProcessor 获取像素值。查看`AutoImageProcessor.__call__()`获取详细信息。
+   `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.ImageClassifierOutputWithNoAttention 或 `tuple(torch.FloatTensor)`
一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个`torch.FloatTensor`元组（如果传递`return_dict=False`或`config.return_dict=False`时）包含各种元素，取决于配置（EfficientNetConfig）和输入。 
+   `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, num_channels, height, width)`的`torch.FloatTensor`元组。模型在每个阶段输出的隐藏状态（也称为特征图）。
EfficientNetForImageClassification 的前向方法，覆盖了`__call__`特殊方法。
虽然前向传播的步骤需要在此函数内定义，但应该在之后调用`Module`实例，而不是在此处调用，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。
示例：
```py
>>> from transformers import AutoImageProcessor, EfficientNetForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("google/efficientnet-b7")
>>> model = EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7")
>>> 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