Hugging Face's logo

Transformers documentation

TVP

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2023-03-09 et ajouté à Hugging Face Transformers le 2023-11-22.

TVP

Aperçu

Le cadre de sollicitation texte-visuel (TVP) a été proposé dans l’article Text-Visual Prompting for Efficient 2D Temporal Video Grounding de Yimeng Zhang, Xin Chen, Jinghan Jia, Sijia Liu et Ke Ding.

L'abstract de l'article est le suivant :

Dans cet article, nous étudions le problème de l’ancrage temporel de vidéos (TVG), qui vise à prédire les points de départ et de fin des instants décrits par une phrase textuelle au sein d’une longue vidéo non découpée. Grâce aux caractéristiques visuelles 3D de fine granularité, les techniques de TVG ont réalisé des progrès remarquables ces dernières années. Toutefois, la forte complexité des réseaux de neurones convolutifs 3D (CNN) rend l’extraction de caractéristiques visuelles 3D denses chronophage, ce qui exige des ressources mémoire et de calcul importantes. En vue d’un TVG efficace, nous proposons un nouveau cadre de sollicitation texte-visuel (TVP), qui intègre des motifs de perturbation optimisés (que nous appelons « prompts ») à la fois aux entrées visuelles et aux caractéristiques textuelles d’un modèle de TVG. En contraste marqué avec les CNN 3D, nous montrons que le TVP nous permet de co-entraîner efficacement l’encodeur visuel et l’encodeur linguistique dans un modèle de TVG 2D et d’améliorer les performances de la fusion de caractéristiques inter-modales en n’utilisant que des caractéristiques visuelles 2D creuses de faible complexité. De plus, nous proposons une perte Temporal-Distance IoU (TDIoU) pour un apprentissage efficace du TVG. Des expériences sur deux jeux de données de référence, Charades-STA et ActivityNet Captions, montrent empiriquement que le TVP proposé améliore significativement les performances du TVG 2D (par exemple, une amélioration de 9,79 % sur Charades-STA et de 30,77 % sur ActivityNet Captions) et atteint une accélération de l’inférence de 5× par rapport au TVG utilisant des caractéristiques visuelles 3D.

Cette recherche aborde le repérage temporel de vidéos (TVG), qui consiste à identifier les instants de début et de fin d’événements spécifiques dans une vidéo longue, tels que décrits par une phrase textuelle. Le promptage texte-visuel (TVP) est proposé pour améliorer le TVG. Le TVP consiste à intégrer des motifs spécialement conçus, appelés « prompts », dans les composants d’entrée visuels (basés sur des images) et textuels (basés sur des mots) d’un modèle de TVG. Ces prompts fournissent un contexte spatio-temporel supplémentaire, améliorant la capacité du modèle à déterminer précisément les horaires des événements dans la vidéo. L’approche utilise des entrées visuelles 2D au lieu d’entrées 3D. Bien que les entrées 3D offrent plus de détails spatio-temporels, elles sont également plus longues à traiter. L’utilisation d’entrées 2D avec la méthode de promptage vise à fournir des niveaux de contexte et de précision similaires de manière plus efficace.

drawing TVP architecture. Taken from the original paper.

Ce modèle a été contribué par Jiqing Feng. Le code d'origine peut être trouvé ici.

Conseils et exemples d'utilisation

Les prompts sont des motifs de perturbation optimisés, qui sont ajoutés aux images vidéo d’entrée ou aux caractéristiques textuelles. L’ensemble universel désigne l’utilisation du même ensemble exact de prompts pour toute entrée, ce qui signifie que ces prompts sont ajoutés de manière cohérente à toutes les images vidéo et aux caractéristiques textuelles, indépendamment du contenu de l’entrée.

TVP est composé d'un encodeur visuel et d'un encodeur intermodal. Il s'agit d'un ensemble universel de prompts visuels et de prompts textuels destinés à être intégrés, respectivement, aux trames vidéo échantillonnées et aux caractéristiques textuelles. Plus précisément, un ensemble de prompts visuels distincts est appliqué, dans l'ordre, aux trames échantillonnées uniformément d'une vidéo non rognée.

L'objectif de ce modèle est d'intégrer des prompts entraînables à la fois dans les entrées visuelles et les caractéristiques textuelles pour les problèmes de localisation temporelle de vidéos (TVG). En principe, on peut appliquer n'importe quel encodeur visuel ou intermodal dans l'architecture proposée.

Le TvpProcessor encapsule BertTokenizer et TvpImageProcessor en une seule instance afin d’encoder le texte et de préparer les images, respectivement.

L’exemple suivant montre comment exécuter le repérage temporel de vidéos à l’aide de TvpProcessor et TvpForVideoGrounding.

import av
import cv2
import numpy as np
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, f"Not a valid clip_idx {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", device_map="auto")

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")

Astuces :

  • Cette implémentation de TVP utilise BertTokenizer pour générer des embeddings de texte et le modèle Resnet-50 pour calculer les embeddings visuels.
  • Les points de contrôle pour le modèle pré-entraîné tvp-base sont disponibles.
  • Veuillez vous reporter à Table 2 pour les performances de TVP sur la tâche de Temporal Video Grounding.

TvpConfig

classe transformers.TvpConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedistance_loss_weight: float = 1.0duration_loss_weight: float = 0.1visual_prompter_type: str = 'framepad'visual_prompter_apply: str = 'replace'visual_prompt_size: int = 96max_img_size: int = 448num_frames: int = 48vocab_size: int = 30522type_vocab_size: int = 2hidden_size: int = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12max_position_embeddings: int = 512max_grid_col_position_embeddings: int = 100max_grid_row_position_embeddings: int = 100hidden_dropout_prob: float | int = 0.1hidden_act: str = 'gelu'layer_norm_eps: float = 1e-12initializer_range: float = 0.02attention_probs_dropout_prob: float | int = 0.1pad_token_id: int | None = None )

Paramètres

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone.
  • distance_loss_weight (float, facultatif, valeur par défaut 1.0) — Le poids de la perte de distance.
  • duration_loss_weight (float, facultatif, valeur par défaut 0.1) — Le poids de la perte de durée.
  • visual_prompter_type (str, facultatif, par défaut "framepad") — Type de visuel prompt. Le type de bourrage. Framepad signifie bourrage sur chaque image. Doit être « framepad » ou « framedownpad »
  • visual_prompter_apply (str, facultatif, valeur par défaut "replace") — La méthode d'application du prompt visuel. « Replace » signifie utiliser la valeur du prompt pour modifier la valeur d'origine dans les entrées visuelles. Doit être l'une des valeurs suivantes : « replace », « add » ou « remove ».
  • visual_prompt_size (int, facultatif, valeur par défaut : 96) — La taille du prompt visuel.
  • max_img_size (int, facultatif, par défaut 448) — La taille maximale de l'image.
  • num_frames (int, facultatif, valeur par défaut : 48) — Le nombre d'images extraites d'une vidéo.
  • vocab_size (int, facultatif, par défaut 30522) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • type_vocab_size (int, facultatif, par défaut 2) — La taille du vocabulaire des token_type_ids.
  • hidden_size (int, facultatif, par défaut 768) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 3072) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 12) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • max_position_embeddings (int, facultatif, valeur par défaut : 512) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048).
  • max_grid_col_position_embeddings (int, facultatif, valeur par défaut : 100) — Nombre maximal de tuiles horizontales d'une image vidéo.
  • max_grid_row_position_embeddings (int, facultatif, valeur par défaut : 100) — Nombre maximal de patches verticaux d'une image vidéo.
  • hidden_dropout_prob (Union[float, int], facultatif, par défaut 0.1) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-12) — L'épsilon utilisé par les couches de normalisation de couche.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • attention_probs_dropout_prob (Union[float, int], facultatif, par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • pad_token_id (int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

Ceci est la classe de configuration destinée à stocker la configuration d'un TvpModel. Elle est utilisée pour instancier un modèle Tvp en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de Intel/tvp-base

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

TvpImageProcessor

classe transformers.TvpImageProcessor

< >

( **kwargs: *<class 'transformers.models.tvp.image_processing_tvp.TvpImageProcessorKwargs'> )

Paramètres

  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'longest_edge' -- 448}) : Définit les dimensions maximales de l'entrée du modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 448, 'width': 448}) : Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 448, 'width': 448}) : La taille au format {"height": int, "width" int} à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si pad_size n'est pas fourni, les images seront rembourrées à la plus grande hauteur et largeur du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_flip_channel_order (bool, kwargs, facultatif, par défaut self.do_flip_channel_order) — Indique s'il faut inverser l'ordre des canaux de l'image, de RGB à BGR.
  • constant_values (float, kwargs ou List[float], facultatif, valeur par défaut self.constant_values) — Valeur utilisée pour remplir la zone de bourrage lorsque pad_mode est 'constant'.
  • pad_mode (str, kwargs, facultatif, valeur par défaut self.pad_mode) — Mode de bourrage à utiliser — 'constant', 'edge', 'reflect' ou 'symmetric'.

Construit un processeur d’images TvpImageProcessor.

prétraiter

< >

( videos: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], list[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]], list[list[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]]]]**kwargs: *<class 'transformers.models.tvp.image_processing_tvp.TvpImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • videos (ImageInput ou list[ImageInput] ou list[list[ImageInput]]) — Images à prétraiter.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_flip_channel_order (bool, kwargs, facultatif, par défaut self.do_flip_channel_order) — Indique s'il faut inverser l'ordre des canaux de l'image, de RGB à BGR.
  • constant_values (float, kwargs ou List[float], facultatif, valeur par défaut self.constant_values) — Valeur utilisée pour remplir la zone de bourrage lorsque pad_mode est 'constant'.
  • pad_mode (str, kwargs, facultatif, valeur par défaut self.pad_mode) — Mode de bourrage à utiliser — 'constant', 'edge', 'reflect' ou 'symmetric'.

Retourne

~image_processing_base.BatchFeature

  • data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

TvpImageProcessorPil

classe transformers.TvpImageProcessorPil

< >

( **kwargs: *<class 'transformers.models.tvp.image_processing_pil_tvp.TvpImageProcessorKwargs'> )

Paramètres

  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'longest_edge' -- 448}) : Définit les dimensions maximales de l'entrée du modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 448, 'width': 448}) : Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 448, 'width': 448}) : La taille au format {"height": int, "width" int} à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si pad_size n'est pas fourni, les images seront rembourrées à la plus grande hauteur et largeur du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_flip_channel_order (bool, kwargs, facultatif, par défaut self.do_flip_channel_order) — Indique s'il faut inverser l'ordre des canaux de l'image, de RGB à BGR.
  • constant_values (float, kwargs ou List[float], facultatif, valeur par défaut self.constant_values) — Valeur utilisée pour remplir la zone de bourrage lorsque pad_mode est 'constant'.
  • pad_mode (str, kwargs, facultatif, valeur par défaut self.pad_mode) — Mode de bourrage à utiliser — 'constant', 'edge', 'reflect' ou 'symmetric'.

Construit un processeur d’images TvpImageProcessor.

prétraiter

< >

( videos: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], list[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]], list[list[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]]]]**kwargs: *<class 'transformers.models.tvp.image_processing_pil_tvp.TvpImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • videos (ImageInput ou list[ImageInput] ou list[list[ImageInput]]) — Images à prétraiter.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • do_flip_channel_order (bool, kwargs, facultatif, par défaut self.do_flip_channel_order) — Indique s'il faut inverser l'ordre des canaux de l'image, de RGB à BGR.
  • constant_values (float, kwargs ou List[float], facultatif, valeur par défaut self.constant_values) — Valeur utilisée pour remplir la zone de bourrage lorsque pad_mode est 'constant'.
  • pad_mode (str, kwargs, facultatif, valeur par défaut self.pad_mode) — Mode de bourrage à utiliser — 'constant', 'edge', 'reflect' ou 'symmetric'.

Retourne

~image_processing_base.BatchFeature

  • data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

TvpProcessor

classe transformers.TvpProcessor

< >

( image_processor = Nonetokenizer = None**kwargs )

Paramètres

  • image_processor (TvpImageProcessor) — Le processeur d’images est une entrée obligatoire.
  • tokenizer (BertTokenizer) — Le tokenizer est une entrée obligatoire.

Construit un TvpProcessor qui encapsule un processeur d’images et un tokenizer en un seul processeur.

TvpProcessor propose toutes les fonctionnalités de TvpImageProcessor et de BertTokenizer. Consultez ~TvpImageProcessor et ~BertTokenizer pour plus d’informations.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], facultatif) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • text (Union[str, list[str], list[list[str]]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissez is_split_into_words=True pour éviter toute ambiguïté avec les entrées en lot.
  • videos (Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], facultatif) — Vidéo à prétraiter. S’attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels vont de 0 à 255. Si vous passez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], facultatif) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d’un tableau NumPy/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

TvpModel

classe transformers.TvpModel

< >

( config: TvpConfig )

Paramètres

  • config (TvpConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle Tvp nu, un transformer qui produit un objet BaseModelOutputWithPooling sans aucune tête spécifique au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Noneinterpolate_pos_encoding: bool = False**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de TvpImageProcessor. Voir TvpImageProcessor.call() pour plus de détails (TvpProcessor utilise TvpImageProcessor pour le traitement des images).
  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
  • interpolate_pos_encoding (bool, facultatif, par défaut False) — Indique s'il faut interpoler les encodages de position pré-entraînés.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (TvpConfig) et des entrées.

La méthode forward de TvpModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

>>> 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

classe transformers.TvpForVideoGrounding

< >

( config: TvpConfig )

Paramètres

  • config (TvpConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle Tvp doté d'une tête de localisation vidéo en partie supérieure, calculant les pertes d'IoU, de distance et de durée.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonelabels: tuple[torch.Tensor] | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Noneinterpolate_pos_encoding: bool = False**kwargs ) → TvpVideoGroundingOutput or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de TvpImageProcessor. Voir TvpImageProcessor.call() pour plus de détails (TvpProcessor utilise TvpImageProcessor pour le traitement des images).
  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • labels (torch.Tensor de forme (batch_size, 3), facultatif) — Les étiquettes contiennent la durée, l'heure de début et l'heure de fin de la vidéo correspondant au texte.
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
  • interpolate_pos_encoding (bool, facultatif, par défaut False) — Indique s'il faut interpoler les encodages de position pré-entraînés.

Retourne

TvpVideoGroundingOutput ou tuple(torch.Tensor)

Un TvpVideoGroundingOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (TvpConfig) et des entrées.

La méthode forward de TvpForVideoGrounding redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque return_loss est True) — Perte Temporal-Distance IoU pour le positionnement temporel de vidéos.

  • logits (torch.Tensor de forme (batch_size, 2)) — Contient start_time/duration et end_time/duration. Il s’agit de l’interval de temps des vidéos correspondant aux textes d’entrée.

  • hidden_states (tuple[torch.Tensor, ...], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Exemples :

>>> 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)
Update on GitHub

←TrOCR UDOP→