Transformers 文档

转换为日文

Hugging Face's logo
加入Hugging Face社区

并获取增强的文档体验

开始使用

TVP

概述

文本-视觉提示(TVP)框架由Yimeng Zhang、Xin Chen、Jinghan Jia、Sijia Liu、Ke Ding在论文《Text-Visual Prompting for Efficient 2D Temporal Video Grounding》中提出,该论文可在线阅读于https://arxiv.org/abs/2303.04995

论文的摘要如下:

(图片展示)架构图。原图来自原文

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

使用技巧和示例

TvpProcessorBertTokenizerTvpImageProcessor 包装成单个实例,分别用于编码文本和准备图像。

以下示例展示了如何使用 TvpProcessorTvpForVideoGrounding 来运行时序视频定位。

import av
import cv2
import numpy as np
import torch
from huggingface_hub import hf_hub_download
from transformers import AutoProcessor, TvpForVideoGrounding


def pyav_decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps):
    '''
    Convert the video from its original fps to the target_fps and decode the video with PyAV decoder.
    Args:
        container (container): pyav container.
        sampling_rate (int): frame sampling rate (interval between two sampled frames).
        num_frames (int): number of frames to sample.
        clip_idx (int): if clip_idx is -1, perform random temporal sampling.
            If clip_idx is larger than -1, uniformly split the video to num_clips
            clips, and select the clip_idx-th video clip.
        num_clips (int): overall number of clips to uniformly sample from the given video.
        target_fps (int): the input video may have different fps, convert it to
            the target video fps before frame sampling.
    Returns:
        frames (tensor): decoded frames from the video. Return None if the no
            video stream was found.
        fps (float): the number of frames per second of the video.
    '''
    video = container.streams.video[0]
    fps = float(video.average_rate)
    clip_size = sampling_rate * num_frames / target_fps * fps
    delta = max(num_frames - clip_size, 0)
    start_idx = delta * clip_idx / num_clips
    end_idx = start_idx + clip_size - 1
    timebase = video.duration / num_frames
    video_start_pts = int(start_idx * timebase)
    video_end_pts = int(end_idx * timebase)
    seek_offset = max(video_start_pts - 1024, 0)
    container.seek(seek_offset, any_frame=False, backward=True, stream=video)
    frames = {}
    for frame in container.decode(video=0):
        if frame.pts < video_start_pts:
            continue
        frames[frame.pts] = frame
        if frame.pts > video_end_pts:
            break
    frames = [frames[pts] for pts in sorted(frames)]
    return frames, fps


def decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps):
    '''
    Decode the video and perform temporal sampling.
    Args:
        container (container): pyav container.
        sampling_rate (int): frame sampling rate (interval between two sampled frames).
        num_frames (int): number of frames to sample.
        clip_idx (int): if clip_idx is -1, perform random temporal sampling.
            If clip_idx is larger than -1, uniformly split the video to num_clips
            clips, and select the clip_idx-th video clip.
        num_clips (int): overall number of clips to uniformly sample from the given video.
        target_fps (int): the input video may have different fps, convert it to
            the target video fps before frame sampling.
    Returns:
        frames (tensor): decoded frames from the video.
    '''
    assert clip_idx >= -2, "Not a valied clip_idx {}".format(clip_idx)
    frames, fps = pyav_decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps)
    clip_size = sampling_rate * num_frames / target_fps * fps
    index = np.linspace(0, clip_size - 1, num_frames)
    index = np.clip(index, 0, len(frames) - 1).astype(np.int64)
    frames = np.array([frames[idx].to_rgb().to_ndarray() for idx in index])
    frames = frames.transpose(0, 3, 1, 2)
    return frames


file = hf_hub_download(repo_id="Intel/tvp_demo", filename="AK2KG.mp4", repo_type="dataset")
model = TvpForVideoGrounding.from_pretrained("Intel/tvp-base")

decoder_kwargs = dict(
    container=av.open(file, metadata_errors="ignore"),
    sampling_rate=1,
    num_frames=model.config.num_frames,
    clip_idx=0,
    num_clips=1,
    target_fps=3,
)
raw_sampled_frms = decode(**decoder_kwargs)

text = "a person is sitting on a bed."
processor = AutoProcessor.from_pretrained("Intel/tvp-base")
model_inputs = processor(
    text=[text], videos=list(raw_sampled_frms), return_tensors="pt", max_text_length=100#, size=size
)

model_inputs["pixel_values"] = model_inputs["pixel_values"].to(model.dtype)
output = model(**model_inputs)

def get_video_duration(filename):
    cap = cv2.VideoCapture(filename)
    if cap.isOpened():
        rate = cap.get(5)
        frame_num = cap.get(7)
        duration = frame_num/rate
        return duration
    return -1

duration = get_video_duration(file)
start, end = processor.post_process_video_grounding(output.logits, duration)

print(f"The time slot of the video corresponding to the text \"{text}\" is from {start}s to {end}s")

提示

  • 此 Tvp 的实现使用 BertTokenizer 生成文本嵌入,并使用 Resnet-50 模型计算视觉嵌入。
  • 已发布预训练的 tvp-base 检查点。
  • 请参阅 表 2 了解 TVP 在时序视频定位任务上的性能。

TvpConfig

transformers.TvpConfig

< >

( backbone_config = None backbone = None use_pretrained_backbone = False use_timm_backbone = False backbone_kwargs = None distance_loss_weight = 1.0 duration_loss_weight = 0.1 visual_prompter_type = 'framepad' visual_prompter_apply = 'replace' visual_prompt_size = 96 max_img_size = 448 num_frames = 48 vocab_size = 30522 hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 max_position_embeddings = 512 max_grid_col_position_embeddings = 100 max_grid_row_position_embeddings = 100 hidden_dropout_prob = 0.1 hidden_act = 'gelu' layer_norm_eps = 1e-12 initializer_range = 0.02 attention_probs_dropout_prob = 0.1 **kwargs )

参数

  • backbone_config(《预训练配置 或 dict可选)— 网络骨干模型的配置。
  • backbone(《字符串,可选)— 当 backbone_configNone 时,使用的网络骨干名称。如果 use_pretrained_backboneTrue,则从此处加载 timm 或 transformers 库中的相应预训练权重。如果 use_pretrained_backboneFalse,则读取骨干配置并将其设置为随机权重以初始化骨干。
  • use_pretrained_backbone(《布尔值,可选,默认为 False)— 是否为骨干使用预训练权重。
  • use_timm_backbone (布尔值, 可选, 默认为 False) — 是否从 timm 库中加载 backbone。如果为 False,则从 transformers 库中加载 backbone。
  • backbone_kwargs (字典, 可选) — 在从检查点加载时传递给 AutoBackbone 的关键字参数,例如 {'out_indices': (0, 1, 2, 3)}。如果设置了 backbone_config,则不能指定。
  • distance_loss_weight (浮点数, 可选, 默认为 1.0) — 距离损失的权重。
  • visual_prompt_size (int, 可选, 默认为 96) — 视觉提示的大小。
  • max_img_size (int, 可选, 默认为 448) — 最大帧大小。
  • num_frames (int, 可选, 默认为 48) — 从视频中提取的帧数。
  • vocab_size (int, 可选, 默认为 30522) — TVP 文本模型的词汇量。定义了在调用 TvpModelinputs_ids 可以表示的不同标记的数量。
  • hidden_size (int, 可选,默认为 768) — 编码层维度。
  • intermediate_size (int, 可选,默认为 3072) — Transformer 编码器中“中间”层(即前馈层)的维度。
  • num_hidden_layers (int, 可选,默认为 12) — Transformer 编码器中的隐藏层数。
  • num_attention_heads (int, 可选,默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • max_position_embeddings (int, 可选,默认为512) — 此模型可能使用的最大序列长度。通常设置一个较大的值以防万一(例如,512或1024或2048)。
  • max_grid_col_position_embeddings (int, 可选,默认为100) — 视频帧中水平补丁的最大数量。
  • max_grid_row_position_embeddings (int, 可选,默认为100) — 视频帧中垂直补丁的最大数量。
  • hidden_dropout_prob (float, 可选,默认为0.1) — 隐藏层的dropout概率。
  • hidden_act (strfunction,可选,默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,支持 "gelu""relu""selu""gelu_new""quick_gelu"
  • layer_norm_eps (float,可选,默认为 1e-12) — 层归一化层使用的 epsilon 值。
  • initializer_range (float,可选,默认为 0.02) — 初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • attention_probs_dropout_prob (float, 可选, 默认值为0.1) — 注意力层的dropout概率。

此配置类用于存储TvpModel的配置。它用于根据指定的参数实例化一个Tvp模型,定义模型架构。使用默认值实例化配置将为Intel/tvp-base架构提供一个类似的配置。

配置对象继承自PretrainedConfig,可用于控制模型输出。有关更多信息,请参阅PretrainedConfig的文档。

from_backbone_config

< >

( backbone_config: PretrainedConfig **kwargs ) TvpConfig

参数

返回值

TvpConfig

配置对象的一个实例

从预训练的骨干模型配置中实例化一个 TvpConfig(或其派生类)。

to_dict

< >

( ) Dict[str, any]

返回值

Dict[str, any]

这个配置实例的所有属性的字典,

将此实例序列化为 Python 字典。重写默认的 to_dict()

TvpImageProcessor

transformers.TvpImageProcessor

< >

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_pad: bool = True pad_size: Dict = None constant_values: Union = 0 pad_mode: PaddingMode = <PaddingMode.CONSTANT: 'constant'> do_normalize: bool = True do_flip_channel_order: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

  • do_resize (bool, 可选,默认为 True) — 是否将图像的(高度,宽度)尺寸调整到指定的 size。可以由 preprocess 方法中的 do_resize 参数覆盖。
  • size (Dict[str, int] 可选,默认为 {“longest_edge” -- 448}):调整大小后的输出图像尺寸。图像的最长边将被调整到 size["longest_edge"],同时保持原始图像的宽高比。可以通过“preprocess”方法中的“size”参数重写。
  • resample (PILImageResampling可选,默认为 Resampling.BILINEAR) —— 如果调整图像大小,则使用重采样过滤器。可以通过“preprocess”方法中的“resample”参数重写。
  • do_center_crop (bool可选,默认为 True) —— 是否将图像居中裁剪到指定的 crop_size。可以通过“preprocess”方法中的“do_center_crop”参数重写。
  • crop_sizeDict[str, int],可选,默认为 {"height" -- 448, "width": 448}):应用中心裁剪后的图像大小。在 preprocess 方法中的 crop_size 参数可以覆盖该值。
  • do_rescalebool,可选,默认为 True)— 是否按指定的比例 rescale_factor 调整图像。可以在 preprocess 方法中的 do_rescale 参数中覆盖该值。
  • rescale_factorintfloat,可选,默认为 1/255)— 如果要调整图像大小,则定义要使用的比例因子。可以在 preprocess 方法中的 rescale_factor 参数中覆盖该值。
  • do_pad (bool, 可选, 默认为 True) — 是否填充图像。可以通过 preprocess 方法中的 do_pad 参数进行覆盖。
  • pad_size (Dict[str, int], 可选, 默认为 {"height" -- 448, "width": 448}): 填充后图像的大小。可以通过 preprocess 方法中的 pad_size 参数进行覆盖。
  • constant_values (Union[float, Iterable[float]], 可选, 默认为 0) — 填充图像时使用的填充值。
  • pad_mode (PaddingMode, 可选, 默认为 PaddingMode.CONSTANT) — 使用何种填充模式。
  • do_normalize (bool, 可选,默认为 True) — 是否规范化图像。可以在 preprocess 方法的 do_normalize 参数中进行覆写。
  • do_flip_channel_order (bool, 可选,默认为 True) — 是否将颜色通道从 RGB 转换为 BGR。可以在 preprocess 方法的 do_flip_channel_order 参数中进行覆写。
  • image_mean (floatList[float]可选,默认为 IMAGENET_STANDARD_MEAN) — 如果规范化图像时使用的均值。这是一个与图像通道数量相对应的浮点数或浮点数列表。可以在 preprocess 方法的 image_mean 参数中进行覆写。
  • image_std (floatList[float]可选,默认为 IMAGENET_STANDARD_STD) — 在归一化图像时使用的标准差。这是一个浮点数或浮点数列表,长度等于图像中的通道数。可以通过 preprocess 方法中的 image_std 参数进行覆盖。

构建 Tvp 图像处理器。

预处理

< >

( videos: 联合 do_resize: bool = None size: Dict = None resample: 重采样 = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_pad: bool = None pad_size: Dict = None constant_values: 联合 = None pad_mode: 填充模式 = None do_normalize: bool = None do_flip_channel_order: bool = None image_mean: 联合 = None image_std: 联合 = None return_tensors: 联合 = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 联合 = None )

参数

  • videos (ImageInputList[ImageInput]List[List[ImageInput]]) — 需要预处理的帧。
  • do_resize (bool, 可选,默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选,默认为 self.size) — 应用调整大小操作后的图像大小。
  • resample (PILImageResampling, 可选,默认为 self.resample) — 如果调整图像大小时要使用的重采样过滤器。这可以是枚举 PILImageResampling 中的值,只有当 do_resize 设置为 True 时才有作用。
  • do_center_crop (布尔值, 可选, 默认为 self.do_centre_crop) — 是否执行图像居中裁剪。
  • crop_size (字典[str, 整数], 可选, 默认为 self.crop_size) — 应用居中裁剪后的图像大小。
  • do_rescale (布尔值, 可选, 默认为 self.do_rescale) — 是否重新缩放图像值到 [0 - 1] 范围内。
  • rescale_factorfloat,可选,默认为self.rescale_factor) — 如果设置了do_rescaleTrue,则用于调整图像大小的缩放因子。
  • do_padbool,可选,默认为True) — 是否填充图像。可以由preprocess方法中的do_pad参数覆盖。
  • pad_sizeDict[str, int],可选,默认为{"height": 448, "width": 448}):填充操作后的图像大小。可以由preprocess方法中的pad_size参数覆盖。
  • constant_valuesUnion[float, Iterable[float]]可选,默认为0)— 图像填充时的填充值。
  • pad_modePaddingMode可选,默认为“PaddingMode.CONSTANT”)— 使用何种模式进行填充。
  • do_normalizebool可选,默认为self.do_normalize)— 是否对图像进行归一化。
  • do_flip_channel_order (bool, 可选,默认为 self.do_flip_channel_order) — 是否翻转图像的通道顺序。
  • image_mean (floatList[float], 可选,默认为 self.image_mean) — 图像均值。
  • image_std (floatList[float], 可选,默认为 self.image_std) — 图像标准差。

预处理图像或图像批次。

TvpProcessor

transformers.TvpProcessor

< >

( image_processor = None tokenizer = None **kwargs )

参数

构建一个 TVP 处理器,该处理器将 TVP 图像处理程序和 Bert 文本分类器封装成一个单独的处理程序。

TvpProcessor 提供了 TvpImageProcessorBertTokenizerFast 的所有功能。请参阅 调用()decode() 获取更多信息。

__call__

< >

( text = None videos = None return_tensors = None **kwargs ) BatchEncoding

参数

  • text (str, List[str], List[List[str]]) — 需要编码的序列或序列批次。每个序列可以是字符串或字符串列表(预处理过的字符串)。如果序列以字符串列表的形式提供(预处理过的字符串),则必须设置 is_split_into_words=True(以清除与序列批次的歧义)。
  • videos (List[PIL.Image.Image], List[np.ndarray], List[torch.Tensor], List[List[PIL.Image.Image]], List[List[np.ndarrray]], — List[List[torch.Tensor]]): 需要准备的视频或视频批次。每个视频应该是一系列帧,可以是 PIL 图像或 NumPy 数组。在 NumPy 数组/PyTorch 张量的情况下,每个帧应该具有形状 (H, W, C),其中 H 和 W 是帧的高度和宽度,C 是通道数量。
  • return_tensors (strTensorType, 可选) — 如果设置,将返回特定框架的张量。可接受值如下:
    • 'tf': 返回 TensorFlow tf.constant 对象。
    • 'pt': 返回 PyTorch torch.Tensor 对象。
    • 'np': 返回 NumPy np.ndarray 对象。
    • 'jax': 返回 JAX jnp.ndarray 对象。

返回值

BatchEncoding

BatchEncoding 包含以下字段

  • input_ids — 向模型提供令牌 ID 的列表。当 text 不是 None 时返回。
  • attention_mask — 用于指定模型应关注的token索引列表(当返回return_attention_mask=True或如果“attention_mask”self.model_input_names中,并且textNone)。
  • pixel_values — 要输入到模型中的像素值。当videosNone时返回。

主方法用于准备一个或多个序列和图像以供模型使用。如果textNone,此方法会将textkwargs参数传递给BertTokenizerFast的call()方法来编码文本。如果要准备图像,当videosNone时,此方法会将videoskwargs参数传递给TvpImageProcessor的call()方法。请查阅上述两个方法的文档以获取更多信息。

TvpModel

transformers.TvpModel

< >

( 配置 )

参数

  • config (TvpConfig) — 拥有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关联的权重,只加载配置。请参阅 from_pretrained() 方法来加载模型权重。

直接输出的 Tvp 模型 transformer,输出 BaseModelOutputWithPooling 对象,顶部没有任何特定头。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档中有关通用使用和行为的所有信息。

前向

< >

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • input_ids(形状为 (batch_size, sequence_length)torch.LongTensor)—词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()什么是输入 ID?
  • pixel_values(形状为 (batch_size, num_frames, num_channels, height, width)torch.FloatTensor)—像素值。像素值可以使用 TvpImageProcessor 获取。有关详细信息,请参阅 TvpImageProcessor.call()
  • attention_mask(形状为 (batch_size, sequence_length)torch.FloatTensor可选)—避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 范围内:

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), 可选) — 空白所选注意力模块头部的掩码。掩码值选在 [0, 1]

    • 1 表示头部 未屏蔽
    • 0 表示头部 已屏蔽
  • output_attentions (bool, 可选) — 是否返回所有注意力层中的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (, 可选) — 是否返回ModelOutput而不是普通的元组。
  • interpolate_pos_encoding (, 可选, 默认为False) — 是否插值预训练图像提示编码和位置编码。

返回值

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

A transformers.modeling_outputs.BaseModelOutputWithPooling或一个包含各种元素的元组`tuple(torch.FloatTensor)`(如果传入`return_dict=False`或在配置中设置了`config.return_dict=False`),这些元素取决于配置(例如<class 'transformers.models.tvp.configuration_tvp.TvpConfig'>)和输入。

  • last_hidden_state (torch.FloatTensor形状(batch_size, sequence_length, hidden_size)) — 模型输出最后一个层隐藏状态的序列。

  • pooler_output (torch.FloatTensor形状(batch_size, hidden_size)) — 第一个token(分类token)在通过用于辅助预训练任务的层进一步处理后的最后一个层隐藏状态。例如,对于BERT系列模型,这返回经过线性层和双曲正切激活函数处理的分类token。线性层权重在预训练期间从下一个句子预测(分类)目标中训练。

  • 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后的注意力权重,用于在自注意力头中进行加权平均。

《TvpModel》的前向方法覆盖了特殊方法__call__

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

示例

>>> import torch
>>> from transformers import AutoConfig, AutoTokenizer, TvpModel

>>> model = TvpModel.from_pretrained("Jiqing/tiny-random-tvp")

>>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")

>>> pixel_values = torch.rand(1, 1, 3, 448, 448)
>>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
>>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)

TvpForVideoGrounding

class transformers.TvpForVideoGrounding

< >

( 配置 )

参数

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

顶部有视频基础头的Tvp模型,计算IoU、距离和持续时间损失。

此模型是PyTorch torch.nn.Module的子类。将其用作常规PyTorch模块,并参阅PyTorch文档,了解所有与通用使用和行为相关的内容。

前向

< >

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None labels: Tuple = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中的输入序列标记的索引。索引可以通过 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()输入 ID 是什么?
  • pixel_values (torch.FloatTensor 的形状为 (batch_size, num_frames, num_channels, height, width)) — 像素值。可以通过使用 TvpImageProcessor 获取像素值。有关详细信息,请参阅 TvpImageProcessor.call()
  • attention_mask (torch.FloatTensor 的形状为 (batch_size, sequence_length)可选) — 避免在对填充标记索引执行注意力的掩码。掩码值在 [0, 1] 范围内选择:

  • 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 而不是一个普通的元组。
  • interpolate_pos_encoding (bool, 可选, 默认为 False) — 是否插值预训练图像垫提示符编码和位置编码。
  • labels (torch.FloatTensor 形状 (batch_size, 3)可选) — 包含视频的时长、开始时间和结束时间与文本对应的标签。

返回值

transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutputtuple(torch.FloatTensor)

A transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False)包括根据配置(<class 'transformers.models.tvp.configuration_tvp.TvpConfig'>)和输入的各种元素。

  • loss (torch.FloatTensor 形状 (1,)可选,当 return_loss=True 时返回) — 视频定位的时间距离 IoU 损失。
  • logits (torch.FloatTensor 形状 (batch_size, 2)) — 包含起始时间/持续时间和结束时间/持续时间。它是与输入文本对应的视频的时间段。
  • 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)

TvpForVideoGrounding 前向方法覆盖了 `__call__` 特殊方法。

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

示例

>>> import torch
>>> from transformers import AutoConfig, AutoTokenizer, TvpForVideoGrounding

>>> model = TvpForVideoGrounding.from_pretrained("Jiqing/tiny-random-tvp")

>>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")

>>> pixel_values = torch.rand(1, 1, 3, 448, 448)
>>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
>>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)
< > 在 GitHub 上更新