Transformers 4.37 中文文档(六十四)(4)

简介: Transformers 4.37 中文文档(六十四)

Transformers 4.37 中文文档(六十四)(3)https://developer.aliyun.com/article/1564125


BeitForImageClassification

class transformers.BeitForImageClassification

< source >

( config: BeitConfig )

参数

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

Beit 模型变压器,顶部带有图像分类头(线性层位于补丁标记的最终隐藏状态的平均值之上),例如用于 ImageNet。

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

forward

<来源>

( pixel_values: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 BeitImageProcessor.call()。
  • head_mask (torch.FloatTensor,形状为(num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间:
  • 1 表示头部未被遮蔽,
  • 0 表示头部被遮蔽。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • labels (torch.LongTensor,形状为(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=Falseconfig.return_dict=False)包含各种元素,具体取决于配置(BeitConfig)和输入。

  • 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=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor元组(如果模型有嵌入层,则为嵌入的输出+每个阶段的输出)。模型在每个阶段输出的隐藏状态(也称为特征图)。
  • attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, patch_size, sequence_length)torch.FloatTensor元组(每层一个)。
    注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。

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

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

示例:

>>> from transformers import AutoImageProcessor, BeitForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-patch16-224")
>>> model = BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")
>>> 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

BeitForSemanticSegmentation

class transformers.BeitForSemanticSegmentation

<来源>

( config: BeitConfig )

参数

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

Beit 模型变换器,顶部带有语义分割头,例如用于 ADE20k、CityScapes。

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

forward

<来源>

( pixel_values: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SemanticSegmenterOutput or tuple(torch.FloatTensor)

参数

  • pixel_values(形状为(batch_size, num_channels, height, width)torch.FloatTensor)- 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 BeitImageProcessor.call()。
  • head_mask(形状为(num_heads,)(num_layers, num_heads)torch.FloatTensor可选)- 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值:
  • 1 表示头部未被掩盖
  • 0 表示头部被掩盖
  • output_attentionsbool可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
  • output_hidden_statesbool可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dictbool可选)- 是否返回一个 ModelOutput 而不是一个普通的元组。
  • labels(形状为(batch_size, height, width)torch.LongTensor可选)- 用于计算损失的地面真实语义分割地图。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回

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

一个 transformers.modeling_outputs.SemanticSegmenterOutput 或一个torch.FloatTensor元组(如果传递了return_dict=False或当config.return_dict=False时)包括根据配置(BeitConfig)和输入的各种元素。

  • loss(形状为(1,)torch.FloatTensor可选,当提供labels时返回)- 分类(或回归,如果config.num_labels==1)损失。
  • logits(形状为(batch_size, config.num_labels, logits_height, logits_width)torch.FloatTensor)- 每个像素的分类分数。
    返回的 logits 不一定与作为输入传递的pixel_values具有相同的大小。这是为了避免进行两次插值并在用户需要将 logits 调整为原始图像大小时丢失一些质量。您应该始终检查您的 logits 形状并根据需要调整大小。
  • hidden_statestuple(torch.FloatTensor)可选,当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回)- 形状为(batch_size, patch_size, hidden_size)torch.FloatTensor元组(一个用于嵌入的输出,如果模型有嵌入层,+ 一个用于每个层的输出)。
    模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。
  • attentionstuple(torch.FloatTensor)可选,当传递output_attentions=Trueconfig.output_attentions=True时返回)- 形状为(batch_size, num_heads, patch_size, sequence_length)torch.FloatTensor元组(每个层一个)。
    在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

BeitForSemanticSegmentation 前向方法,覆盖__call__特殊方法。

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

示例:

>>> from transformers import AutoImageProcessor, BeitForSemanticSegmentation
>>> 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("microsoft/beit-base-finetuned-ade-640-640")
>>> model = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits

JAXHide JAX 内容

FlaxBeitModel

class transformers.FlaxBeitModel

< source >

( config: BeitConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config(BeitConfig)- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
  • dtypejax.numpy.dtype可选,默认为jax.numpy.float32)- 计算的数据类型。可以是jax.numpy.float32jax.numpy.float16(在 GPU 上)和jax.numpy.bfloat16(在 TPU 上)之一。
    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定,所有计算将使用给定的dtype执行。
    请注意,这仅指定计算的数据类型,不影响模型参数的数据类型。
    如果您希望更改模型参数的 dtype,请参阅 to_fp16()和 to_bf16()。

裸 Beit 模型变压器输出原始隐藏状态,没有特定的头部。

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

这个模型也是一个flax.linen.Module子类。将其用作常规的 Flax linen 模块,并参考 Flax 文档以获取与一般用法和行为相关的所有内容。

最后,这个模型支持 JAX 的固有特性,例如:

__call__

<来源>

( pixel_values bool_masked_pos = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling or tuple(torch.FloatTensor)

返回

transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 transformers.models.beit.modeling_flax_beit.FlaxBeitModelOutputWithPooling 或一个torch.FloatTensor元组(如果传递return_dict=Falseconfig.return_dict=False)包含根据配置()和输入的不同元素。

  • last_hidden_state (jnp.ndarray,形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  • pooler_output (jnp.ndarray,形状为(batch_size, hidden_size)) — 如果config.use_mean_pooling设置为 True,则是补丁标记的最后一层隐藏状态的平均值(不包括*[CLS]标记)。如果设置为 False,则将返回[CLS]*标记的最终隐藏状态。
  • hidden_states (tuple(jnp.ndarray), 可选, 当传递output_hidden_states=Trueconfig.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)jnp.ndarray元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层输出的隐藏状态加上初始嵌入输出。
  • attentions (tuple(jnp.ndarray), 可选, 当传递output_attentions=Trueconfig.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)jnp.ndarray元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

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

示例:

>>> from transformers import AutoImageProcessor, FlaxBeitModel
>>> 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("microsoft/beit-base-patch16-224-pt22k-ft22k")
>>> model = FlaxBeitModel.from_pretrained("microsoft/beit-base-patch16-224-pt22k-ft22k")
>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

FlaxBeitForMaskedImageModeling

class transformers.FlaxBeitForMaskedImageModeling

<来源>

( config: BeitConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config(BeitConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32jax.numpy.float16(在 GPU 上)和jax.numpy.bfloat16(在 TPU 上)之一。
    这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定,所有计算将使用给定的dtype执行。
    请注意,这仅指定计算的数据类型,不影响模型参数的数据类型。
    如果希望更改模型参数的数据类型,请参阅 to_fp16()和 to_bf16()。

在顶部添加一个“语言”建模头的 Beit 模型变换器(用于预测视觉标记)。

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

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

最后,此模型支持 JAX 的固有特性,例如:

__call__

<来源>

( pixel_values bool_masked_pos = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxMaskedLMOutput or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个torch.FloatTensor元组(如果传递return_dict=False或当config.return_dict=False时)包含根据配置()和输入的不同元素。

  • logits(形状为(batch_size, sequence_length, config.vocab_size)jnp.ndarray) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
  • hidden_statestuple(jnp.ndarray)可选,当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)jnp.ndarray元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
    模型在每一层输出的隐藏状态加上初始嵌入输出。
  • attentionstuple(jnp.ndarray)可选,当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)jnp.ndarray元组(每层一个)。
    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

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

bool_masked_pos(形状为(batch_size, num_patches)numpy.ndarray):布尔掩码位置。指示哪些补丁被屏蔽(1),哪些没有(0)。

示例:

>>> from transformers import AutoImageProcessor, BeitForMaskedImageModeling
>>> 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("microsoft/beit-base-patch16-224-pt22k")
>>> model = BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k")
>>> inputs = image_processor(images=image, return_tensors="np")
>>> outputs = model(**inputs)
>>> logits = outputs.logits

FlaxBeitForImageClassification

class transformers.FlaxBeitForImageClassification

<来源>

( config: BeitConfig input_shape = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config(BeitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
  • dtype (jax.numpy.dtype, optional, 默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32, jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 中的一个。
    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了,所有的计算将使用给定的 dtype 进行。
    请注意,这只指定了计算的数据类型,不影响模型参数的数据类型。
    如果您希望更改模型参数的数据类型,请参阅 to_fp16() 和 to_bf16()。

Beit 模型变换器,顶部带有一个图像分类头(一个线性层位于补丁标记的最终隐藏状态的平均值之上),例如用于 ImageNet。

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

这个模型也是一个 flax.linen.Module 的子类。将其用作常规的 Flax linen 模块,并参考 Flax 文档以获取有关一般用法和行为的所有相关信息。

最后,这个模型支持 JAX 的内在特性,比如:

__call__

<来源>

( pixel_values bool_masked_pos = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput or tuple(torch.FloatTensor)

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或一个 torch.FloatTensor 元组(如果传递 return_dict=Falseconfig.return_dict=False)包含根据配置 () 和输入的不同元素。

  • logits (jnp.ndarray,形状为 (batch_size, config.num_labels)) — 分类(如果 config.num_labels==1 则为回归)得分(SoftMax 之前)。
  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size)jnp.ndarray 元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
    模型在每一层输出的隐藏状态以及初始嵌入输出。
  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=Trueconfig.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)jnp.ndarray 元组(每一层一个)。
    自注意力头中的注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

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

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

示例:

>>> from transformers import AutoImageProcessor, FlaxBeitForImageClassification
>>> 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("microsoft/beit-base-patch16-224")
>>> model = FlaxBeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")
>>> 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 = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])


Transformers 4.37 中文文档(六十四)(5)https://developer.aliyun.com/article/1564127

相关实践学习
部署Stable Diffusion玩转AI绘画(GPU云服务器)
本实验通过在ECS上从零开始部署Stable Diffusion来进行AI绘画创作,开启AIGC盲盒。
目录
打赏
0
1
1
0
256
分享
相关文章
Transformers 4.37 中文文档(四十二)(4)
Transformers 4.37 中文文档(四十二)
43 3
Transformers 4.37 中文文档(四十二)(3)
Transformers 4.37 中文文档(四十二)
36 2
Transformers 4.37 中文文档(六十四)(1)
Transformers 4.37 中文文档(六十四)
36 0
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等