X-CLIP
概述
X-CLIP 模型由 Bolin Ni、Houwen Peng、Minghao Chen、Songyang Zhang、Gaofeng Meng、Jianlong Fu、Shiming Xiang、Haibin Ling 在 Expanding Language-Image Pretrained Models for General Video Recognition 中提出。X-CLIP 是 CLIP 的最小扩展，用于视频。该模型由文本编码器、跨帧视觉编码器、多帧集成 Transformer 和视频特定提示生成器组成。
论文中的摘要如下：
对比语言-图像预训练在从网络规模数据中学习视觉-文本联合表示方面取得了巨大成功，展示了对各种图像任务的显著“零样本”泛化能力。然而，如何有效地将这种新的语言-图像预训练方法扩展到视频领域仍然是一个开放问题。在这项工作中，我们提出了一种简单而有效的方法，该方法直接将预训练的语言-图像模型应用于视频识别，而不是从头开始预训练一个新模型。更具体地说，为了捕获帧在时间维度上的长程依赖关系，我们提出了一种跨帧注意机制，该机制显式地交换了跨帧的信息。这种模块轻量级，可以无缝地插入预训练的语言-图像模型中。此外，我们提出了一种视频特定提示方案，该方案利用视频内容信息生成区分性的文本提示。大量实验表明，我们的方法是有效的，可以推广到不同的视频识别场景。特别是，在完全监督的设置下，我们的方法在 Kinectics-400 上实现了 87.1% 的 top-1 准确率，而 FLOPs 比 Swin-L 和 ViViT-H 少 12 倍。在零样本实验中，我们的方法在两种流行协议下分别在 top-1 准确率方面超过了目前的最佳方法 +7.6% 和 +14.9%。在少样本场景中，当标记数据极其有限时，我们的方法比之前的最佳方法分别高出 +32.1% 和 +23.1%。
提示
- X-CLIP 的使用与 CLIP 相同。
X-CLIP 架构。摘自 原始论文。此模型由 nielsr 贡献。原始代码可以在这里找到 这里。
资源
以下是官方 Hugging Face 和社区（由 🌎 表示）资源列表，帮助您开始使用 X-CLIP。
- X-CLIP 的演示笔记本可以在 这里 找到。
如果您有兴趣提交资源以包含在此处，请随时打开一个拉取请求，我们将对其进行审核！资源应理想地展示一些新内容，而不是重复现有的资源。
XCLIPProcessor
class transformers.XCLIPProcessor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (VideoMAEImageProcessor, 可选) — 图像处理器是必需的输入。
- tokenizer (CLIPTokenizerFast, 可选) — 分词器是必需的输入。
构造一个 X-CLIP 处理器，它将 VideoMAE 图像处理器和 CLIP 分词器包装到一个单一处理器中。
XCLIPProcessor 提供了 VideoMAEImageProcessor 和 CLIPTokenizerFast 的所有功能。有关更多信息，请参阅 __call__() 和 decode()。
此方法将所有参数转发到 CLIPTokenizerFast 的 batch_decode()。有关更多信息，请参阅此方法的 docstring。
此方法将所有参数转发到 CLIPTokenizerFast 的 decode()。有关更多信息，请参阅此方法的 docstring。
XCLIPConfig
class transformers.XCLIPConfig
< source >( text_config = None vision_config = None projection_dim = 512 prompt_layers = 2 prompt_alpha = 0.1 prompt_hidden_act = 'quick_gelu' prompt_num_attention_heads = 8 prompt_attention_dropout = 0.0 prompt_projection_dropout = 0.0 logit_scale_init_value = 2.6592 **kwargs )
参数
- text_config (
dict, optional) — 用於初始化 XCLIPTextConfig 的配置选项字典。 - vision_config (
dict, optional) — 用於初始化 XCLIPVisionConfig 的配置选项字典。 - projection_dim (
int, optional, defaults to 512) — 文本和视觉投影层的维度。 - prompt_layers (
int, optional, defaults to 2) — 视频特定提示生成器中的层数。 - prompt_alpha (
float, optional, defaults to 0.1) — 在视频特定提示生成器中使用的 alpha 值。 - prompt_hidden_act (
strorfunction, optional, defaults to"quick_gelu") — 视频特定提示生成器中的非线性激活函数 (函数或字符串)。 如果是字符串，则支持"gelu"、"relu"、"selu"和"gelu_new""quick_gelu"。 - prompt_num_attention_heads (
int, optional, defaults to 8) — 视频特定提示生成器中交叉注意力的注意力头数。 - logit_scale_init_value (
float, 可选, 默认为 2.6592) — logit_scale 参数的初始值。默认值与原始 XCLIP 实现一致。 - kwargs (可选) — 关键字参数字典。
XCLIPConfig 是用于存储 XCLIPModel 配置的配置类。它用于根据指定的参数实例化 X-CLIP 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将生成与 X-CLIP microsoft/xclip-base-patch32 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
from_text_vision_configs
< 源代码 >( text_config: XCLIPTextConfig vision_config: XCLIPVisionConfig **kwargs ) → XCLIPConfig
从 xclip 文本模型配置和 xclip 视觉模型配置实例化 XCLIPConfig（或派生类）。
XCLIPTextConfig
类 transformers.XCLIPTextConfig
< 源代码 >( vocab_size = 49408 hidden_size = 512 intermediate_size = 2048 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 77 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 49408) — X-CLIP 文本模型的词汇量大小。定义调用 XCLIPModel 时传递的inputs_ids可以表示的不同 token 数量。 - hidden_size (
int, 可选, 默认为 512) — 编码器层和池化层的维度。 - intermediate_size (
int, 可选, 默认为 2048) — Transformer 编码器中“中间”（即前馈）层的维度。 - num_hidden_layers (
int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, 可选, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数。 - max_position_embeddings (
int, 可选, 默认为 77) — 该模型可能使用的最大序列长度。通常将其设置为一个较大的值，以防万一（例如，512 或 1024 或 2048）。 - hidden_act (
str或function, 可选, 默认为"quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"、"gelu_new"和"quick_gelu"。 - layer_norm_eps (
float, 可选, 默认为 1e-5) — 层归一化层使用的 epsilon。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的丢弃率。 - initializer_range (
float, 可选, 默认为 0.02) — 初始化所有权重矩阵的截断正态分布初始化器的标准差。 - initializer_factor (
float, 可选, 默认为 1) — 初始化所有权重矩阵的因子（应保持为 1，在初始化测试中内部使用）。
这是用于存储 XCLIPModel 配置的配置类。它用于根据指定的参数实例化一个 X-CLIP 模型，定义模型架构。使用默认值实例化配置将产生与 X-CLIP microsoft/xclip-base-patch32 架构相似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import XCLIPTextModel, XCLIPTextConfig
>>> # Initializing a XCLIPTextModel with microsoft/xclip-base-patch32 style configuration
>>> configuration = XCLIPTextConfig()
>>> # Initializing a XCLIPTextConfig from the microsoft/xclip-base-patch32 style configuration
>>> model = XCLIPTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configXCLIPVisionConfig
这是用于存储 XCLIPModel 配置的配置类。它用于根据指定的参数实例化一个 X-CLIP 模型，定义模型架构。使用默认值实例化配置将产生与 X-CLIP microsoft/xclip-base-patch32 架构相似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import XCLIPVisionModel, XCLIPVisionConfig
>>> # Initializing a XCLIPVisionModel with microsoft/xclip-base-patch32 style configuration
>>> configuration = XCLIPVisionConfig()
>>> # Initializing a XCLIPVisionModel model from the microsoft/xclip-base-patch32 style configuration
>>> model = XCLIPVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configXCLIPModel
class transformers.XCLIPModel
< 源代码 >( config: XCLIPConfig )
参数
- config (XCLIPConfig) — 模型配置类，包含模型的所有参数。 使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。 查看 from_pretrained() 方法来加载模型权重。
此模型是 PyTorch torch.nn.Module 子类。 将其用作常规的 PyTorch 模块，并参考 PyTorch 文档了解与一般用法和行为相关的所有事项。
forward
< 源代码 >( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids 参数 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 返回值
一个 torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。 torch.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意的掩码。[0, 1] 中选择掩码值：
torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记位置的索引。在 [0, config.max_position_embeddings - 1] 范围内选择。 torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。 bool，可选) — 是否返回对比损失。 bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。 bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的 hidden_states。 bool，可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。 transformers.models.x_clip.modeling_x_clip.XCLIPOutput 或 tuple(torch.FloatTensor)transformers.models.x_clip.modeling_x_clip.XCLIPOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置 (<class 'transformers.models.x_clip.configuration_x_clip.XCLIPConfig'>) 和输入的不同元素。
torch.FloatTensor 形状为 (1,)，可选，在 return_loss 为 True 时返回) — 用于视频文本相似性的对比损失。torch.FloatTensor 形状为 (video_batch_size, text_batch_size)) — video_embeds 和 text_embeds 之间的缩放点积分数。这代表视频文本相似性分数。torch.FloatTensor 形状为 (text_batch_size, video_batch_size)) — text_embeds 和 video_embeds 之间的缩放点积分数。这代表文本视频相似性分数。torch.FloatTensor 形状为 (batch_size, output_dim) — 通过将投影层应用于 XCLIPTextModel 的池化输出而获得的文本嵌入。torch.FloatTensor 形状为 (batch_size, output_dim) — 通过将投影层应用于 XCLIPVisionModel 的池化输出而获得的视频嵌入。BaseModelOutputWithPooling) — XCLIPTextModel 的输出。BaseModelOutputWithPooling) — XCLIPVisionModel 的输出。BaseModelOutputWithPooling) — XCLIPMultiframeIntegrationTransformer（简称 MIT）的输出。
XCLIPModel 正向方法覆盖 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例，而不是调用此函数，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import av
>>> import torch
>>> import numpy as np
>>> from transformers import AutoProcessor, AutoModel
>>> 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)
>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = AutoModel.from_pretrained("microsoft/xclip-base-patch32")
>>> inputs = processor(
... text=["playing sports", "eating spaghetti", "go shopping"],
... videos=list(video),
... return_tensors="pt",
... padding=True,
... )
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> logits_per_video = outputs.logits_per_video # this is the video-text similarity score
>>> probs = logits_per_video.softmax(dim=1) # we can take the softmax to get the label probabilities
>>> print(probs)
tensor([[1.9496e-04, 9.9960e-01, 2.0825e-04]])get_text_features
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → text_features (torch.FloatTensor 形状为 (batch_size, output_dim)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。如果您提供了填充，则默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码，以避免对填充标记索引执行注意力。掩码值选择在[0, 1]中：- 1 用于未掩码的标记，
- 0 用于掩码的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]内。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
text_features (torch.FloatTensor 形状为 (batch_size, output_dim)
通过将投影层应用于 XCLIPTextModel 的池化输出获得的文本嵌入。
XCLIPModel 正向方法覆盖 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例，而不是调用此函数，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, AutoModel
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/xclip-base-patch32")
>>> model = AutoModel.from_pretrained("microsoft/xclip-base-patch32")
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)get_video_features
< source >( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → video_features (torch.FloatTensor 形状为 (batch_size, output_dim)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。如果您提供了填充，则默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参见 CLIPImageProcessor.call()。 - return_dict (
bool, 可选) — 是否返回一个ModelOutput 而不是一个简单的元组。
返回值
video_features (torch.FloatTensor 形状为 (batch_size, output_dim)
通过将投影层应用于XCLIPVisionModel 和 XCLIPMultiframeIntegrationTransformer 的池化输出获得的视频嵌入。
XCLIPModel 正向方法覆盖 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例，而不是调用此函数，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import av
>>> import torch
>>> import numpy as np
>>> from transformers import AutoProcessor, AutoModel
>>> 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)
>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = AutoModel.from_pretrained("microsoft/xclip-base-patch32")
>>> inputs = processor(videos=list(video), return_tensors="pt")
>>> video_features = model.get_video_features(**inputs)XCLIPTextModel
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，则默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在[0, 1]中选择掩码值：- 1 表示未掩码的标记，
- 0 表示已掩码的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。
返回值
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或者一个 torch.FloatTensor 元组（如果传递 return_dict=False 或者当 config.return_dict=False 时），包含各种元素，取决于配置 (<class 'transformers.models.x_clip.configuration_x_clip.XCLIPTextConfig'>) 和输入。
-
last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过用于辅助预训练任务的层的进一步处理。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。 线性层权重在预训练期间从下一个句子预测（分类）目标中训练。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或者当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入层的输出，如果模型具有嵌入层，+ 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或者当config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。自注意力头中计算加权平均值所用的注意力 softmax 后的权重。
The XCLIPTextModel 正向方法，覆盖 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例，而不是调用此函数，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XCLIPTextModel
>>> model = XCLIPTextModel.from_pretrained("microsoft/xclip-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/xclip-base-patch32")
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled (EOS token) statesXCLIPVisionModel
forward
< 源代码 >( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充，如果您提供它。像素值可以使用 AutoImageProcessor 获取。详情请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。详情请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。详情请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。
返回值
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或者一个 torch.FloatTensor 元组（如果传递 return_dict=False 或者当 config.return_dict=False 时），包含各种元素，取决于配置 (<class 'transformers.models.x_clip.configuration_x_clip.XCLIPVisionConfig'>) 和输入。
-
last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过用于辅助预训练任务的层的进一步处理。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。 线性层权重在预训练期间从下一个句子预测（分类）目标中训练。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或者当config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入层的输出，如果模型具有嵌入层，+ 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或者当config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。自注意力头中计算加权平均值所用的注意力 softmax 后的权重。
The XCLIPVisionModel 正向方法，覆盖 __call__ 特殊方法。
虽然正向传递的配方需要在此函数中定义，但之后应该调用 Module 实例，而不是调用此函数，因为前者负责运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import av
>>> import torch
>>> import numpy as np
>>> from transformers import AutoProcessor, XCLIPVisionModel
>>> 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 16 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)
>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = XCLIPVisionModel.from_pretrained("microsoft/xclip-base-patch32")
>>> pixel_values = processor(videos=list(video), return_tensors="pt").pixel_values
>>> batch_size, num_frames, num_channels, height, width = pixel_values.shape
>>> pixel_values = pixel_values.reshape(-1, num_channels, height, width)
>>> outputs = model(pixel_values)
>>> last_hidden_state = outputs.last_hidden_state