Transformers 4.37 中文文档(六十四)(3)https://developer.aliyun.com/article/1564125
BeitForImageClassification
class transformers.BeitForImageClassification
( 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=False
或config.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=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 之后,用于计算自注意力头中的加权平均值。
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_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。return_dict
(bool
,可选)- 是否返回一个 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_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, patch_size, 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 之后的注意力权重,用于计算自注意力头中的加权平均值。
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
( 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.float32
、jax.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=False
或config.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=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层输出的隐藏状态加上初始嵌入输出。attentions
(tuple(jnp.ndarray)
, 可选, 当传递output_attentions=True
或config.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.float32
、jax.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_states
(tuple(jnp.ndarray)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。attentions
(tuple(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=False
或 config.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=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的jnp.ndarray
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出。attentions
(tuple(jnp.ndarray)
, optional, 当传递output_attentions=True
或config.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