Transformers 4.37 中文文档（七十二）（3）

Transformers 4.37 中文文档（七十二）（2）https://developer.aliyun.com/article/1564165

TimesformerForVideoClassification

class transformers.TimesformerForVideoClassification

<来源>

( config )

参数

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

TimeSformer 模型变压器，顶部带有视频分类头（在[CLS]标记的最终隐藏状态之上的线性层），例如用于 ImageNet。此模型是 PyTorch 的torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( pixel_values: 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（形状为(batch_size, num_frames, num_channels, height, width)的torch.FloatTensor） — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 VideoMAEImageProcessor.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时）包含各种元素，取决于配置（TimesformerConfig）和输入。

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> import av
>>> import torch
>>> import numpy as np
>>> from transformers import AutoImageProcessor, TimesformerForVideoClassification
>>> from huggingface_hub import hf_hub_download
>>> np.random.seed(0)
>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])
>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices
>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)
>>> # sample 8 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)
>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics")
>>> model = TimesformerForVideoClassification.from_pretrained("facebook/timesformer-base-finetuned-k400")
>>> inputs = image_processor(list(video), return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
...     logits = outputs.logits
>>> # model predicts one of the 400 Kinetics-400 classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
eating spaghetti

UPerNet

huggingface.co/docs/transformers/v4.37.2/en/model_doc/upernet

概述

UPerNet 模型是由肖特、刘英成、周博磊、姜玉宁、孙坚在统一感知解析用于场景理解中提出的。UPerNet 是一个通用框架，可以有效地从图像中分割各种概念，利用任何视觉骨干，如 ConvNeXt 或 Swin。

论文摘要如下：

人类在多个层次上识别视觉世界：我们轻松地对场景进行分类，并检测其中的对象，同时还识别对象的纹理和表面以及它们不同的组成部分。在本文中，我们研究了一个称为统一感知解析的新任务，该任务要求机器视觉系统从给定图像中尽可能识别尽可能多的视觉概念。开发了一个名为  UPerNet  的多任务框架和训练策略，以从异构图像注释中学习。我们在统一感知解析上对我们的框架进行基准测试，并展示它能够有效地从图像中分割各种概念。训练的网络进一步应用于发现自然场景中的视觉知识。

UPerNet 框架。取自原始论文。

该模型由nielsr贡献。原始代码基于 OpenMMLab 的 mmsegmentation 这里。

使用示例

UPerNet 是语义分割的通用框架。可以与任何视觉骨干一起使用，如：

from transformers import SwinConfig, UperNetConfig, UperNetForSemanticSegmentation
backbone_config = SwinConfig(out_features=["stage1", "stage2", "stage3", "stage4"])
config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)

要使用另一个视觉骨干，如 ConvNeXt，只需使用适当的骨干实例化模型：

from transformers import ConvNextConfig, UperNetConfig, UperNetForSemanticSegmentation
backbone_config = ConvNextConfig(out_features=["stage1", "stage2", "stage3", "stage4"])
config = UperNetConfig(backbone_config=backbone_config)
model = UperNetForSemanticSegmentation(config)

请注意，这将随机初始化模型的所有权重。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，帮助您开始使用 UPerNet。

• UPerNet 的演示笔记本可以在这里找到。
  
• UperNetForSemanticSegmentation 由这个示例脚本和笔记本支持。
  
• 另请参阅：语义分割任务指南
  

如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将进行审查！资源应该展示一些新内容，而不是重复现有资源。

UperNetConfig

class transformers.UperNetConfig

<来源>

( backbone_config = None hidden_size = 512 initializer_range = 0.02 pool_scales = [1, 2, 3, 6] use_auxiliary_head = True auxiliary_loss_weight = 0.4 auxiliary_in_channels = 384 auxiliary_channels = 256 auxiliary_num_convs = 1 auxiliary_concat_input = False loss_ignore_index = 255 **kwargs )

参数

• backbone_config (PretrainedConfig或dict, 可选, 默认为ResNetConfig()) — 骨干模型的配置。
  
• hidden_size (int, 可选, 默认为 512) — 卷积层中隐藏单元的数量。
  
• initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• pool_scales (Tuple[int], 可选, 默认为[1, 2, 3, 6]) — 应用于最后特征图的 Pooling Pyramid Module 中使用的池化尺度。
  
• use_auxiliary_head (bool, 可选, 默认为True) — 训练期间是否使用辅助头。
  
• auxiliary_loss_weight (float, 可选, 默认为 0.4) — 辅助头的交叉熵损失的权重。
  
• auxiliary_channels (int，可选，默认为 256) — 辅助头中要使用的通道数。
  
• auxiliary_num_convs (int，可选，默认为 1) — 辅助头中要使用的卷积层数。
  
• auxiliary_concat_input (bool，可选，默认为False) — 是否在分类层之前将辅助头的输出与输入连接。
  
• loss_ignore_index (int，可选，默认为 255) — 损失函数忽略的索引。
  

这是一个配置类，用于存储 UperNetForSemanticSegmentation 的配置。它用于根据指定的参数实例化一个 UperNet 模型，定义模型架构。使用默认值实例化配置将产生类似于 UperNet openmmlab/upernet-convnext-tiny架构的配置。

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

示例：

>>> from transformers import UperNetConfig, UperNetForSemanticSegmentation
>>> # Initializing a configuration
>>> configuration = UperNetConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = UperNetForSemanticSegmentation(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

UperNetForSemanticSegmentation

class transformers.UperNetForSemanticSegmentation

<来源>

( config )

参数

• This模型是 PyTorch torch.nn.Module 子类。使用
  
• it作为常规的  PyTorch 模块，并参考 PyTorch  文档以获取有关一般用法和行为的所有相关信息。配置(UperNetConfig)：模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看  from_pretrained()方法以加载模型权重。
  

UperNet 框架利用任何视觉骨干，例如 ADE20k，CityScapes。

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 SegformerImageProcessor.call()。
  
• output_attentions (bool，可选) — 是否返回骨干具有注意力张量的所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool，可选) — 是否返回骨干的所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
  
• labels (torch.LongTensor，形状为(batch_size, height, width)，可选) — 用于计算损失的地面真实语义分割地图。索引应在[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时）包含根据配置（UperNetConfig）和输入而异的各种元素。

• loss (torch.FloatTensor，形状为(1,), 可选的, 当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
  
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。
  返回的 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 后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例:

>>> from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download
>>> image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny")
>>> model = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny")
>>> filepath = hf_hub_download(
...     repo_id="hf-internal-testing/fixtures_ade20k", filename="ADE_val_00000001.jpg", repo_type="dataset"
... )
>>> image = Image.open(filepath).convert("RGB")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits  # shape (batch_size, num_labels, height, width)
>>> list(logits.shape)
[1, 150, 512, 512]

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