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

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

TableTransformerModel

class transformers.TableTransformerModel

<来源>

( config: TableTransformerConfig )

参数

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

裸 Table Transformer 模型（由骨干和编码器-解码器 Transformer 组成），输出原始隐藏状态，没有特定的头部。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.table_transformer.modeling_table_transformer.TableTransformerModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。默认情况下将忽略填充。
  可以使用 DetrImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
  
• pixel_mask（形状为(batch_size, height, width)的torch.FloatTensor，可选）—遮罩，避免在填充像素值上执行注意力。遮罩值选择在[0, 1]中：

• 1 表示真实像素（即未遮罩），
  
• 0 表示填充像素（即遮罩）。
  

• 注意力蒙版是什么？
  
• decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), 可选) — 默认情况下不使用。可用于屏蔽对象查询。
  
• encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组包括(last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。
  
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递图像的扁平化表示，而不是传递扁平化特征图（骨干网络输出+投影层的输出）。
  
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是用零张量初始化查询。
  
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.models.table_transformer.modeling_table_transformer.TableTransformerModelOutput 或 tuple(torch.FloatTensor)

一个transformers.models.table_transformer.modeling_table_transformer.TableTransformerModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（TableTransformerConfig）和输入的不同元素。

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 元组torch.FloatTensor（一个用于嵌入输出，一个用于每层输出）的形状为(batch_size, sequence_length, hidden_size)。解码器每层输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 元组torch.FloatTensor（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。编码器在每个层的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后使用，用于计算自注意力头中的加权平均值。
  
• intermediate_hidden_states (torch.FloatTensor，形状为 (config.decoder_layers, batch_size, sequence_length, hidden_size)，可选，当 config.auxiliary_loss=True 时返回) — 中间解码器激活，即每个解码器层的输出，每个都经过了一个 layernorm。
  

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

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

示例：

>>> from transformers import AutoImageProcessor, TableTransformerModel
>>> from huggingface_hub import hf_hub_download
>>> from PIL import Image
>>> file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename="example_pdf.png")
>>> image = Image.open(file_path).convert("RGB")
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/table-transformer-detection")
>>> model = TableTransformerModel.from_pretrained("microsoft/table-transformer-detection")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 15, 256]

TableTransformerForObjectDetection

class transformers.TableTransformerForObjectDetection

< source >

( config: TableTransformerConfig )

参数

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

Table Transformer Model（由主干和编码器-解码器 Transformer 组成），顶部带有目标检测头，用于诸如 COCO 检测之类的任务。

这个模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。

forward

< source >

( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.table_transformer.modeling_table_transformer.TableTransformerObjectDetectionOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充。
  可以使用 DetrImageProcessor 获取像素值。有关详细信息，请参阅 DetrImageProcessor.call()。
  
• pixel_mask (torch.FloatTensor，形状为 (batch_size, height, width)，可选) — 遮罩，避免在填充像素值上执行注意力。遮罩值选择在 [0, 1] 中：

• 1 代表真实像素（即 not masked），
  
• 0 代表填充像素（即 masked）。
  

• 什么是注意力遮罩？
  
• decoder_attention_mask (torch.FloatTensor of shape (batch_size, num_queries), optional) — 默认情况下不使用。可用于屏蔽对象查询。
  
• encoder_outputs (tuple(tuple(torch.FloatTensor), optional) — 元组包括（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选，可以选择直接传递图像的扁平化表示，而不是传递骨干网络+投影层的扁平化特征图。
  
• decoder_inputs_embeds (torch.FloatTensor of shape (batch_size, num_queries, hidden_size), optional) — 可选，可以选择直接传递嵌入表示，而不是用零张量初始化查询。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  
• labels (List[Dict] of len (batch_size,), optional) — 用于计算二分匹配损失的标签。字典列表，每个字典至少包含以下 2 个键：‘class_labels’和’boxes’（分别是批次中图像的类标签和边界框）。类标签本身应该是长度为(图像中边界框的数量,)的torch.LongTensor，而边界框应该是形状为(图像中边界框的数量, 4)的torch.FloatTensor。
  

返回

transformers.models.table_transformer.modeling_table_transformer.TableTransformerObjectDetectionOutput 或 tuple(torch.FloatTensor)

一个transformers.models.table_transformer.modeling_table_transformer.TableTransformerObjectDetectionOutput或一个torch.FloatTensor的元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（TableTransformerConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 作为负对数似然（交叉熵）和边界框损失的线性组合的总损失。后者被定义为 L1 损失和广义比例不变 IoU 损失的线性组合。
  
• loss_dict (Dict, optional) — 包含各个损失的字典。用于记录。
  
• logits (torch.FloatTensor of shape (batch_size, num_queries, num_classes + 1)) — 包括无对象在内的所有查询的分类 logits。
  
• pred_boxes (torch.FloatTensor of shape (batch_size, num_queries, 4)) — 所有查询的归一化框坐标，表示为（中心 _x，中心 _y，宽度，高度）。这些值在[0, 1]范围内归一化，相对于批次中每个单独图像的大小（忽略可能的填充）。您可以使用~TableTransformerImageProcessor.post_process_object_detection来检索未归一化的边界框。
  
• auxiliary_outputs (list[Dict], optional) — 可选，仅在激活辅助损失（即config.auxiliary_loss设置为True）并提供标签时返回。它是一个字典列表，包含每个解码器层的上述两个键（logits和pred_boxes）。
  
• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型解码器最后一层的隐藏状态序列。
  
• decoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（嵌入输出和每层输出各一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每层输出的隐藏状态加上初始嵌入输出。
  
• decoder_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor)，optional，当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  
• encoder_last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
  
• encoder_hidden_states (tuple(torch.FloatTensor)，optional，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（嵌入输出和每层输出各一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每层输出的隐藏状态加上初始嵌入输出。
  
• encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoImageProcessor, TableTransformerForObjectDetection
>>> import torch
>>> from PIL import Image
>>> file_path = hf_hub_download(repo_id="nielsr/example-pdf", repo_type="dataset", filename="example_pdf.png")
>>> image = Image.open(file_path).convert("RGB")
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/table-transformer-detection")
>>> model = TableTransformerForObjectDetection.from_pretrained("microsoft/table-transformer-detection")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected table with confidence 1.0 at location [202.1, 210.59, 1119.22, 385.09]

TimeSformer

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/timesformer

概述

TimeSformer 模型在 Facebook Research 的论文TimeSformer: Is Space-Time Attention All You Need for Video Understanding?中提出。这项工作是动作识别领域的里程碑，是第一个视频 Transformer。它启发了许多基于 Transformer 的视频理解和分类论文。

论文摘要如下：

我们提出了一种基于自注意力的视频分类无卷积方法，专门建立在空间和时间上。我们的方法名为“TimeSformer”，通过使标准  Transformer  架构适应视频，直接从一系列帧级补丁中实现时空特征学习。我们的实验研究比较了不同的自注意力方案，并建议“分割注意力”，其中在每个块内分别应用时间注意力和空间注意力，是考虑的设计选择中导致最佳视频分类准确性的。尽管设计全新，TimeSformer  在几个动作识别基准数据集上取得了最先进的结果，包括 Kinetics-400 和 Kinetics-600 上报告的最佳准确性。最后，与 3D   卷积网络相比，我们的模型训练速度更快，可以实现显著更高的测试效率（准确性略有下降），还可以应用于更长的视频剪辑（超过一分钟）。代码和模型可在此处找到：此链接。

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

使用提示

有许多预训练变体。根据模型训练的数据集选择预训练模型。此外，每个剪辑的输入帧数根据模型大小而变化，因此在选择预训练模型时应考虑此参数。

资源

• 视频分类任务指南

TimesformerConfig

class transformers.TimesformerConfig

<来源>

( image_size = 224 patch_size = 16 num_channels = 3 num_frames = 8 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 qkv_bias = True attention_type = 'divided_space_time' drop_path_rate = 0 **kwargs )

参数

• image_size (int，可选，默认为 224）— 每个图像的大小（分辨率）。
  
• patch_size (int，可选，默认为 16）— 每个补丁的大小（分辨率）。
  
• num_channels (int，可选，默认为 3）— 输入通道数。
  
• num_frames (int，可选，默认为 8）— 每个视频中的帧数。
  
• hidden_size (int，可选，默认为 768）— 编码器层和池化层的维度。
  
• num_hidden_layers (int，可选，默认为 12）— Transformer 编码器中的隐藏层数。
  
• num_attention_heads (int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。
  
• intermediate_size (int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。
  
• hidden_act (str或function，可选，默认为"gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
  
• hidden_dropout_prob (float，可选，默认为 0.0）— 嵌入层、编码器和池化层中所有全连接层的丢弃概率。
  
• attention_probs_dropout_prob (float，可选，默认为 0.0）— 注意力概率的丢弃比率。
  
• initializer_range (float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon。
  
• qkv_bias (bool, 可选, 默认为True) — 是否向查询、键和值添加偏置。
  
• attention_type (str, 可选, 默认为"divided_space_time") — 要使用的注意力类型。必须是"divided_space_time"、"space_only"或"joint_space_time"之一。
  
• drop_path_rate (float, 可选, 默认为 0) — 随机深度的丢弃率。
  

这是用于存储 TimesformerModel 配置的配置类。它用于根据指定的参数实例化一个 TimeSformer 模型，定义模型架构。使用默认值实例化配置将产生类似于 TimeSformer facebook/timesformer-base-finetuned-k600架构的配置。

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

示例：

>>> from transformers import TimesformerConfig, TimesformerModel
>>> # Initializing a TimeSformer timesformer-base style configuration
>>> configuration = TimesformerConfig()
>>> # Initializing a model from the configuration
>>> model = TimesformerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

TimesformerModel

class transformers.TimesformerModel

<来源>

( config )

参数

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

裸的 TimeSformer 模型变压器输出原始隐藏状态，没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

前向传播

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_frames, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 VideoMAEImageProcessor.preprocess()。
  
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
  
• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
  
• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
  

返回

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（TimesformerConfig）和输入的各种元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor） — 模型最后一层的隐藏状态序列。
  
• 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, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> import av
>>> import numpy as np
>>> from transformers import AutoImageProcessor, TimesformerModel
>>> 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=4, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)
>>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base")
>>> model = TimesformerModel.from_pretrained("facebook/timesformer-base-finetuned-k400")
>>> # prepare video for the model
>>> inputs = image_processor(list(video), return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 1569, 768]

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