Transformers 文档

RegNet

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始

RegNet

PyTorch TensorFlow Flax

概述

RegNet 模型在 Designing Network Design Spaces 一文中被提出,作者是 Ilija Radosavovic、Raj Prateek Kosaraju、Ross Girshick、Kaiming He、Piotr Dollár。

作者设计搜索空间以执行神经架构搜索 (NAS)。他们首先从高维搜索空间开始,并通过经验性地应用基于当前搜索空间采样的最佳性能模型的约束,迭代地缩小搜索空间。

该论文的摘要如下:

在这项工作中,我们提出了一种新的网络设计范式。我们的目标是帮助增进对网络设计的理解,并发现适用于各种环境的设计原则。我们没有专注于设计单个网络实例,而是设计了参数化网络群体的网络设计空间。整个过程类似于经典的 manual 网络设计,但提升到了设计空间级别。使用我们的方法,我们探索了网络设计的结构方面,并得出了一个低维设计空间,该空间由我们称为 RegNet 的简单、规则网络组成。RegNet 参数化的核心见解非常简单:良好网络的宽度和深度可以用量化的线性函数来解释。我们分析了 RegNet 设计空间,并得出了一些有趣的发现,这些发现与当前的网络设计实践不符。RegNet 设计空间提供了简单快速的网络,这些网络在各种 FLOP 机制中都能很好地工作。在相当的训练设置和 FLOP 下,RegNet 模型优于流行的 EfficientNet 模型,同时在 GPU 上速度提高了 5 倍。

该模型由 Francesco 贡献。该模型的 TensorFlow 版本由 sayakpaulariG23498 贡献。原始代码可以在 这里 找到。

来自 Self-supervised Pretraining of Visual Features in the Wild 的 10B 大型模型,在十亿张 Instagram 图片上训练,可在 hub 上找到

资源

一系列官方 Hugging Face 和社区(🌎 表示)资源,帮助您开始使用 RegNet。

图像分类

如果您有兴趣提交资源以包含在此处,请随时打开 Pull Request,我们将对其进行审核!资源最好展示一些新的东西,而不是重复现有资源。

RegNetConfig

class transformers.RegNetConfig

< >

( num_channels = 3 embedding_size = 32 hidden_sizes = [128, 192, 512, 1088] depths = [2, 6, 12, 2] groups_width = 64 layer_type = 'y' hidden_act = 'relu' **kwargs )

参数

  • num_channels (int, optional, 默认为 3) — 输入通道数。
  • embedding_size (int, optional, 默认为 64) — 嵌入层的维度(隐藏层大小)。
  • hidden_sizes (List[int], optional, 默认为 [256, 512, 1024, 2048]) — 每个阶段的维度(隐藏层大小)。
  • depths (List[int], optional, 默认为 [3, 4, 6, 3]) — 每个阶段的深度(层数)。
  • layer_type (str, optional, 默认为 "y") — 要使用的层类型,可以是 "x"“y”x 层是 ResNet 的 BottleNeck 层,其中 reduction 固定为 1。而 y 层是 x 层,但带有 squeeze and excitation。有关这些层如何构建的详细说明,请参阅论文。
  • hidden_act (str, optional, 默认为 "relu") — 每个块中的非线性激活函数。如果为字符串,则支持 "gelu""relu""selu""gelu_new"
  • downsample_in_first_stage (bool, optional, 默认为 False) — 如果为 True,则第一阶段将使用步长为 2 对输入进行下采样。

这是用于存储 RegNetModel 配置的配置类。它用于根据指定的参数实例化 RegNet 模型,定义模型架构。使用默认值实例化配置将生成类似于 RegNet facebook/regnet-y-040 架构的配置。

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

示例

>>> from transformers import RegNetConfig, RegNetModel

>>> # Initializing a RegNet regnet-y-40 style configuration
>>> configuration = RegNetConfig()
>>> # Initializing a model from the regnet-y-40 style configuration
>>> model = RegNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Pytorch
隐藏 Pytorch 内容

RegNetModel

class transformers.RegNetModel

< >

( config )

参数

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

裸 RegNet 模型,输出原始特征,顶部没有任何特定的 head。此模型是 PyTorch 的 torch.nn.Module 子类。可将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( pixel_values: Tensor output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttentiontuple(torch.FloatTensor)

参数

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

返回值

transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttentiontuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (RegNetConfig) 和输入。

  • 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 时返回) — torch.FloatTensor 元组(对于嵌入的输出,如果模型具有嵌入层,则为一个;对于每一层的输出,则为一个),形状为 (batch_size, num_channels, height, width)

    模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。

RegNetModel forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, RegNetModel
>>> 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("facebook/regnet-y-040")
>>> model = RegNetModel.from_pretrained("facebook/regnet-y-040")

>>> 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, 1088, 7, 7]

RegNetForImageClassification

class transformers.RegNetForImageClassification

< >

( config )

参数

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

RegNet 模型,顶部带有一个图像分类 head(池化特征顶部的线性层),例如用于 ImageNet。

此模型是 PyTorch 的 torch.nn.Module 子类。可将其用作常规 PyTorch 模块,并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_outputs.ImageClassifierOutputWithNoAttentiontuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息,请参阅 ConvNextImageProcessor.call()
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回值

transformers.modeling_outputs.ImageClassifierOutputWithNoAttentiontuple(torch.FloatTensor)

一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (RegNetConfig) 和输入。

  • loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 分类(或回归,如果 config.num_labels==1)损失。
  • logits (torch.FloatTensor,形状为 (batch_size, config.num_labels)) — 分类(或回归,如果 config.num_labels==1)分数(在 SoftMax 之前)。
  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组(对于嵌入的输出,如果模型具有嵌入层,则为一个;对于每个阶段的输出,则为一个),形状为 (batch_size, num_channels, height, width)。 模型在每个阶段输出的隐藏状态(也称为特征图)。

RegNetForImageClassification forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, RegNetForImageClassification
>>> 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("facebook/regnet-y-040")
>>> model = RegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

>>> 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
TensorFlow
隐藏 TensorFlow 内容

TFRegNetModel

class transformers.TFRegNetModel

< >

( config: RegNetConfig *inputs **kwargs )

参数

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

裸 RegNet 模型,输出原始特征,顶部没有任何特定的 head。此模型是 Tensorflow 的 keras.layers.Layer 子类。可将其用作常规 Tensorflow 模块,并参阅 Tensorflow 文档以了解与常规用法和行为相关的所有事项。

call

< >

( pixel_values: Tensor output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None training: bool = False ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndNoAttentiontuple(tf.Tensor)

参数

  • pixel_values (tf.Tensor,形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息,请参阅 ConveNextImageProcessor.__call__
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。

返回值

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndNoAttentiontuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndNoAttention 或一个 tf.Tensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (RegNetConfig) 和输入。

  • last_hidden_state (tf.Tensor,形状为 (batch_size, num_channels, height, width)) — 模型最后一层输出的隐藏状态序列。

  • pooler_output (tf.Tensor,形状为 (batch_size, hidden_size)) — 对空间维度进行池化操作后的最后一层隐藏状态。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(对于嵌入的输出,如果模型具有嵌入层,则为一个;对于每一层的输出,则为一个),形状为 (batch_size, num_channels, height, width)

    模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。

TFRegNetModel forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFRegNetModel
>>> 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("facebook/regnet-y-040")
>>> model = TFRegNetModel.from_pretrained("facebook/regnet-y-040")

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

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 1088, 7, 7]

TFRegNetForImageClassification

class transformers.TFRegNetForImageClassification

< >

( config: RegNetConfig *inputs **kwargs )

参数

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

RegNet 模型,顶部带有一个图像分类 head(池化特征顶部的线性层),例如用于 ImageNet。

此模型是 Tensorflow keras.layers.Layer 子类。将其用作常规 Tensorflow 模块,并参阅 Tensorflow 文档,了解所有与通用用法和行为相关的事项。

call

< >

( pixel_values: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None labels: typing.Optional[tensorflow.python.framework.tensor.Tensor] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None training: bool = False ) transformers.modeling_tf_outputs.TFSequenceClassifierOutputtuple(tf.Tensor)

参数

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

返回值

transformers.modeling_tf_outputs.TFSequenceClassifierOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RegNetConfig) 和输入。

  • loss (形状为 (batch_size, )tf.Tensor, 可选, 当提供 labels 时返回) — 分类(或回归,如果 config.num_labels==1)损失。

  • logits (形状为 (batch_size, config.num_labels)tf.Tensor) — 分类(或回归,如果 config.num_labels==1)得分(在 SoftMax 之前)。

  • hidden_states (tuple(tf.Tensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(embeddings 输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出以及初始 embedding 输出处的隐藏状态。

  • attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

TFRegNetForImageClassification 前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, TFRegNetForImageClassification
>>> 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("facebook/regnet-y-040")
>>> model = TFRegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

>>> 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])
tabby, tabby cat
JAX
隐藏 JAX 内容

FlaxRegNetModel

class transformers.FlaxRegNetModel

< >

( config: RegNetConfig input_shape = (1, 224, 224, 3) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config (RegNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32, jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定,所有计算将使用给定的 dtype 执行。

    请注意,这仅指定计算的数据类型,不影响模型参数的数据类型。

    如果您希望更改模型参数的数据类型,请参阅 to_fp16()to_bf16()

裸 RegNet 模型输出原始特征,顶部没有任何特定的头部。

此模型继承自 FlaxPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解所有与通用用法和行为相关的事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( pixel_values params: dict = None train: bool = False output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

返回值

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (<class 'transformers.models.regnet.configuration_regnet.RegNetConfig'>) 和输入。

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size)jnp.ndarray) — 模型最后一层的输出处的隐藏状态序列。

  • pooler_output (形状为 (batch_size, hidden_size)jnp.ndarray) — 序列的第一个 token(分类 token)的最后一层隐藏状态,通过线性层和 Tanh 激活函数进一步处理。线性层权重从预训练期间的下一句预测(分类)目标中训练而来。

  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 元组(embeddings 输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出以及初始 embedding 输出处的隐藏状态。

  • attentions (tuple(jnp.ndarray), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

FlaxRegNetPreTrainedModel 前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, FlaxRegNetModel
>>> 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("facebook/regnet-y-040")
>>> model = FlaxRegNetModel.from_pretrained("facebook/regnet-y-040")

>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

FlaxRegNetForImageClassification

class transformers.FlaxRegNetForImageClassification

< >

( config: RegNetConfig input_shape = (1, 224, 224, 3) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config (RegNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32, jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定,所有计算将使用给定的 dtype 执行。

    请注意,这仅指定计算的数据类型,不影响模型参数的数据类型。

    如果您希望更改模型参数的数据类型,请参阅 to_fp16()to_bf16()

RegNet 模型,顶部带有一个图像分类 head(池化特征顶部的线性层),例如用于 ImageNet。

此模型继承自 FlaxPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解所有与通用用法和行为相关的事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( pixel_values params: dict = None train: bool = False output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttentiontuple(torch.FloatTensor)

返回值

transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttentiontuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxImageClassifierOutputWithNoAttention 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (<class 'transformers.models.regnet.configuration_regnet.RegNetConfig'>) 和输入。

  • logits (形状为 (batch_size, config.num_labels)jnp.ndarray) — 分类(或回归,如果 config.num_labels==1)得分(在 SoftMax 之前)。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递 output_hidden_states=True 时返回或当
  • config.output_hidden_states=True): jnp.ndarray 元组(embeddings 输出一个,如果模型有 embedding 层,+ 每个阶段的输出一个),形状为 (batch_size, num_channels, height, width)。模型在每个阶段输出处的隐藏状态(也称为特征图)。

FlaxRegNetPreTrainedModel 前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, FlaxRegNetForImageClassification
>>> from PIL import Image
>>> import jax
>>> import requests

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> logits = outputs.logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = jax.numpy.argmax(logits, axis=-1)
>>> print("Predicted class:", model.config.id2label[predicted_class_idx.item()])
< > 在 GitHub 上更新