Hugging Face's logo

Transformers documentation

Video Vision Transformer (ViViT)

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

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 29 de marzo de 2021 y se contribuyó a Hugging Face Transformers el 11 de julio de 2023.

Video Vision Transformer (ViViT)

FlashAttention SDPA

Resumen

El modelo Vivit se propuso en ViViT: A Video Vision Transformer de Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Lučić, Cordelia Schmid. El artículo propone uno de los primeros conjuntos de modelos basados puramente en transformers que tuvieron éxito para la comprensión de video.

El resumen del artículo es el siguiente:

Presentamos modelos basados en transformers puros para la clasificación de videos, aprovechando el éxito reciente de este tipo de modelos en la clasificación de imágenes. Nuestro modelo extrae tokens espaciotemporales del video de entrada, que luego se codifican mediante una serie de capas de transformer. Para manejar las largas secuencias de tokens presentes en los videos, proponemos varias variantes eficientes de nuestro modelo que factorizan las dimensiones espacial y temporal de la entrada. Aunque se sabe que los modelos basados en transformers solo son efectivos cuando se dispone de grandes conjuntos de datos de entrenamiento, demostramos cómo podemos regularizar eficazmente el modelo durante el entrenamiento y aprovechar modelos de imagen preentrenados para poder entrenar con conjuntos de datos relativamente pequeños. Realizamos estudios de ablación exhaustivos y logramos resultados de última generación en varios benchmarks de clasificación de videos, incluidos Kinetics 400 y 600, Epic Kitchens, Something-Something v2 y Moments in Time, superando a los métodos anteriores basados en redes convolucionales 3D profundas.

Este modelo fue aportado por jegormeister. El código original (escrito en JAX) se puede encontrar aquí.

Uso de la atención de producto escalar de puntos (SDPA)

PyTorch incluye un operador nativo de atención de producto escalar (SDPA) como parte de torch.nn.functional. Esta función abarca varias implementaciones que pueden aplicarse según las entradas y el hardware en uso. Consulte la documentación oficial o la página de GPU Inference para obtener más información.

SDPA se utiliza de forma predeterminada para torch>=2.1.1 cuando hay una implementación disponible, pero también puede establecer attn_implementation="sdpa" en from_pretrained() para solicitar explícitamente el uso de SDPA.

from transformers import VivitModel


model = VivitModel.from_pretrained("google/vivit-b-16x2-kinetics400", attn_implementation="sdpa", device_map="auto")
...

Para obtener las mejores mejoras de velocidad, recomendamos cargar el modelo en media precisión (por ejemplo, torch.float16 o torch.bfloat16).

En un benchmark local (A100-40GB, PyTorch 2.3.0, SO Ubuntu 22.04) con float32 y el modelo google/vivit-b-16x2-kinetics400, observamos las siguientes mejoras de velocidad durante la inferencia.

Entrenamiento

num_training_stepsbatch_sizees cudaAceleración (%)Memoria pico eager (MB)mem. pico de sdpa (MB)Ahorro de memoria (%)
1001True7.1222575.285932.54130.364

Inferencia

num_batchesbatch_sizees cudaes la mitadAceleración (%)Memoria eager (MB)Mem BT (MB)Memoria guardada (%)
201TrueFalse15.422715.807317.079125.75
202TrueFalse17.1461234.75447.175176.122
204TrueFalse18.0932275.82709.864220.6
208TrueFalse19.2844358.191233.24253.393

VivitConfig

clase transformers.VivitConfig

< >

( 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 = Noneimage_size: int | list[int] | tuple[int, int] = 224num_frames: int = 32tubelet_size: list[int] | tuple[int, ...] = (2, 16, 16)num_channels: int = 3hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu_fast'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06qkv_bias: bool = Truepooler_output_size: int | None = Nonepooler_act: str = 'tanh' )

Parámetros

  • image_size (Union[int, list[int], tuple[int, int]], opcional, valor predeterminado 224) — El tamaño (resolución) de cada imagen.
  • num_frames (int, opcional, valor predeterminado 32) — El número de fotogramas de cada vídeo.
  • tubelet_size (list[int], opcional, valor predeterminado [2, 16, 16]) — El tamaño (resolución) de cada tubelet.
  • num_channels (int, opcional, valor predeterminado 3) — El número de canales de entrada.
  • hidden_size (int, opcional, valor predeterminado 768) — Dimensión de las representaciones ocultas.
  • num_hidden_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer.
  • num_attention_heads (int, opcional, valor predeterminado 12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 3072) — Dimensión de las representaciones del MLP.
  • hidden_act (str, opcional, valor predeterminado gelu_fast) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], opcional, valor predeterminado 0.0) — La probabilidad de dropout para todas las capas totalmente conectadas en las incrustaciones, el codificador y el pooler.
  • attention_probs_dropout_prob (Union[float, int], opcional, valor predeterminado 0.0) — La proporción de dropout para las probabilidades de atención.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-06) — La epsilon utilizada por las capas de normalización de capa.
  • qkv_bias (bool, opcional, valor predeterminado True) — Si se debe añadir un sesgo a las consultas, claves y valores.
  • pooler_output_size (int, opcional) — Dimensionalidad de la capa pooler. Si es None, el valor predeterminado es hidden_size.
  • pooler_act (str, opcional, valor predeterminado "tanh") — La función de activación que se utilizará en el pooler.

Esta es la clase de configuración para almacenar la configuración de un VivitModel. Se utiliza para instanciar un modelo Vivit según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de google/vivit-b-16x2-kinetics400

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> from transformers import VivitConfig, VivitModel

>>> # Initializing a ViViT google/vivit-b-16x2-kinetics400 style configuration
>>> configuration = VivitConfig()

>>> # Initializing a model (with random weights) from the google/vivit-b-16x2-kinetics400 style configuration
>>> model = VivitModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

VivitImageProcessor

clase transformers.VivitImageProcessor

< >

( do_resize: bool = Truesize: dict[str, int] | None = Noneresample: Resampling = <Resampling.BILINEAR: 2>do_center_crop: bool = Truecrop_size: dict[str, int] | None = Nonedo_rescale: bool = Truerescale_factor: int | float = 0.00784313725490196offset: bool = Truedo_normalize: bool = Trueimage_mean: float | list[float] | None = Noneimage_std: float | list[float] | None = None**kwargs )

Parámetros

  • do_resize (bool, opcional, valor predeterminado True) — Indica si se deben redimensionar las dimensiones (altura, ancho) de la imagen al size especificado. Puede ser anulado por el parámetro do_resize en el método preprocess.
  • size (dict[str, int] opcional, valor predeterminado {"shortest_edge" -- 256}): Tamaño de la imagen de salida tras el redimensionado. El lado más corto de la imagen se redimensionará a size["shortest_edge"] manteniendo la relación de aspecto de la imagen original. Puede ser sobrescrito por size en el método preprocess.
  • resample (PILImageResampling, opcional, valor predeterminado Resampling.BILINEAR) — Filtro de remuestreo que se utilizará si se cambia el tamaño de la imagen. Puede ser sobrescrito por el parámetro resample en el método preprocess.
  • do_center_crop (bool, opcional, valor predeterminado True) — Indica si se debe recortar la imagen al centro hasta el crop_size especificado. Puede ser anulado por el parámetro do_center_crop del método preprocess.
  • crop_size (dict[str, int], opcional, valor predeterminado {"height" -- 224, "width": 224}): Tamaño de la imagen después de aplicar el recorte central. Puede ser sobrescrito por el parámetro crop_size en el método preprocess.
  • do_rescale (bool, opcional, valor predeterminado True) — Indica si se debe reescalar la imagen según el factor de escala especificado rescale_factor. Puede ser anulado por el parámetro do_rescale del método preprocess.
  • rescale_factor (int o float, opcional, valor predeterminado 1/127.5) — Define el factor de escala a utilizar si se reescala la imagen. Puede ser anulado por el parámetro rescale_factor en el método preprocess.
  • offset (bool, opcional, valor predeterminado True) — Indica si se debe escalar la imagen en ambas direcciones, negativa y positiva. Puede sobrescribirse mediante offset en el método preprocess.
  • do_normalize (bool, opcional, valor predeterminado True) — Indica si se debe normalizar la imagen. Puede ser anulado por el parámetro do_normalize en el método preprocess.
  • image_mean (float o list[float], opcional, valor predeterminado IMAGENET_STANDARD_MEAN) — Media a utilizar si se normaliza la imagen. Es un float o una lista de floats con la longitud del número de canales de la imagen. Puede sobrescribirse mediante el parámetro image_mean del método preprocess.
  • image_std (float o list[float], opcional, valor predeterminado IMAGENET_STANDARD_STD) — Desviación estándar a utilizar si se normaliza la imagen. Es un float o una lista de floats con la longitud del número de canales de la imagen. Puede ser sobrescrito por el parámetro image_std en el método preprocess.

Construye un procesador de imágenes Vivit.

preprocesar

< >

( videos: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]do_resize: bool | None = Nonesize: dict[str, int] | None = Noneresample: PIL.Image.Resampling | None = Nonedo_center_crop: bool | None = Nonecrop_size: dict[str, int] | None = Nonedo_rescale: bool | None = Nonerescale_factor: float | None = Noneoffset: bool | None = Nonedo_normalize: bool | None = Noneimage_mean: float | list[float] | None = Noneimage_std: float | list[float] | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonedata_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'>input_data_format: str | transformers.image_utils.ChannelDimension | None = None )

Parámetros

  • videos (ImageInput) — Fotogramas de video para preprocesar. Espera un único lote o un lote de fotogramas de video con valores de píxeles que van de 0 a 255. Si se pasan fotogramas con valores de píxeles entre 0 y 1, establezca do_rescale=False.
  • do_resize (bool, opcional, valor predeterminado self.do_resize) — Si se debe redimensionar la imagen.
  • size (dict[str, int], opcional, valor predeterminado self.size) — Tamaño de la imagen después de aplicar el redimensionado.
  • resample (PILImageResampling, opcional, valor predeterminado self.resample) — Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_center_crop (bool, opcional, valor predeterminado self.do_centre_crop) — Indica si se debe recortar la imagen por el centro.
  • crop_size (dict[str, int], opcional, valor predeterminado self.crop_size) — Tamaño de la imagen después de aplicar el recorte central.
  • do_rescale (bool, opcional, valor predeterminado self.do_rescale) — Si se deben reescalar los valores de la imagen entre [-1 - 1] si offset es True, o [0, 1] en caso contrario.
  • rescale_factor (float, opcional, por defecto self.rescale_factor) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • offset (bool, opcional, valor predeterminado self.offset) — Indica si se debe escalar la imagen en ambas direcciones, negativa y positiva.
  • do_normalize (bool, opcional, valor predeterminado self.do_normalize) — Si se debe normalizar la imagen.
  • image_mean (float o list[float], opcional, valor predeterminado self.image_mean) — Media de la imagen.
  • image_std (float o list[float], opcional, valor predeterminado self.image_std) — Desviación estándar de la imagen.
  • return_tensors (str o TensorType, opcional) — El tipo de tensores a devolver. Puede ser uno de:
    • Unset: Devuelve una lista de np.ndarray.
    • TensorType.PYTORCH o 'pt': devuelve un lote de tipo torch.Tensor.
    • TensorType.NUMPY o 'np': Devuelve un lote de tipo np.ndarray.
  • data_format (ChannelDimension o str, opcional, por defecto ChannelDimension.FIRST) — Formato de la dimensión de canal para la imagen de salida. Puede ser uno de:
    • ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • Unset: Utiliza el formato de dimensión de canal inferido de la imagen de entrada.
  • input_data_format (ChannelDimension o str, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).

Preprocesa una imagen o un lote de imágenes.

VivitVideoProcessor

clase transformers.VivitVideoProcessor

< >

( **kwargs: *<class 'transformers.processing_utils.VideosKwargs'> )

Parámetros

  • do_convert_rgb (bool, kwargs, opcional, valor predeterminado True) — Si se debe convertir la imagen a RGB.
  • do_resize (bool, kwargs, opcional, valor predeterminado True) — Si se debe redimensionar la imagen.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto {'shortest_edge' -- 256}): Describe las dimensiones de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado False) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, por defecto 2) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los valores de la enumeración PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, kwargs, opcional, valor predeterminado True) — Si se debe reescalar la imagen.
  • rescale_factor (float, kwargs, opcional, valor predeterminado 0.00784313725490196) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, kwargs, opcional, valor predeterminado True) — Si se debe normalizar la imagen.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado [0.5, 0.5, 0.5]) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize se establece en True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, valor predeterminado [0.5, 0.5, 0.5]) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_center_crop (bool, kwargs, opcional, valor predeterminado True) — Si se debe recortar la imagen centrada.
  • do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, por defecto {'height' -- 224, 'width': 224}): Tamaño de la imagen de salida tras aplicar center_crop.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • do_sample_frames (bool, kwargs, opcional, valor predeterminado False) — Si se deben muestrear fotogramas del video antes de procesarlo o si se debe procesar el video completo.
  • video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pase ningún metadato a menos que intente decodificar el video manualmente antes de procesarlo
  • fps (Annotated[int | float | None, None], kwargs) — Fotogramas objetivo a muestrear por segundo cuando do_sample_frames=True.
  • num_frames (Annotated[int | None, None], kwargs) — Número máximo de fotogramas a muestrear cuando do_sample_frames=True.
  • return_metadata (bool, kwargs, opcional, valor predeterminado False) — Indica si se debe devolver o no la metadatos del vídeo. Los metadatos del vídeo son un objeto que contiene información sobre la duración del vídeo, los fps, el backend de decodificación, etc.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos np.ndarray de NumPy.
  • **kwargs (VideosKwargs, opcional) — Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

Construye un procesador de video VivitVideoProcessor.

preprocesar

< >

( videos: 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]]]**kwargs: *<class 'transformers.processing_utils.VideosKwargs'> ) → ~image_processing_base.BatchFeature

Parámetros

  • 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]]]) — Vídeo a preprocesar. Espera un único vídeo o un lote de vídeos con valores de píxeles que van de 0 a 255. Si se pasan vídeos con valores de píxeles entre 0 y 1, establece do_rescale=False.
  • do_convert_rgb (bool, kwargs, opcional) — Si se debe convertir la imagen a RGB.
  • do_resize (bool, kwargs, opcional) — Si se debe redimensionar la imagen.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Describe las dimensiones de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de remuestreo a utilizar si se redimensiona la imagen. Puede ser uno de los enum PILImageResampling. Solo tiene efecto si do_resize está establecido en True.
  • do_rescale (bool, kwargs, opcional) — Si se debe reescalar la imagen.
  • rescale_factor (float, kwargs, opcional) — Factor de reescalado para reescalar la imagen si do_rescale está establecido en True.
  • do_normalize (bool, kwargs, opcional) — Si se debe normalizar la imagen.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Media de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si do_normalize está establecido en True.
  • do_center_crop (bool, kwargs, opcional) — Si se debe recortar la imagen centrada.
  • do_pad (bool, kwargs, opcional) — Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamaño de la imagen de salida tras aplicar center_crop.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Solo se admite ChannelDimension.FIRST. Se añadió para garantizar la compatibilidad con los procesadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — El formato de la dimensión de canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales se infiere a partir de la imagen de entrada. Puede ser uno de:
    • "channels_first" o ChannelDimension.FIRST: imagen en formato (num_channels, height, width).
    • "channels_last" o ChannelDimension.LAST: imagen en formato (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos de entrada.
  • do_sample_frames (bool, kwargs, opcional) — Si se deben muestrear fotogramas del video antes de procesarlo o si se debe procesar el video completo.
  • video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadatos del video que contienen información sobre la duración total, los fps y el número total de fotogramas. Se utilizarán para muestrear fotogramas del video o calcular marcas de tiempo. No pase ningún metadato a menos que intente decodificar el video manualmente antes de procesarlo
  • fps (Annotated[int | float | None, None], kwargs) — Fotogramas objetivo a muestrear por segundo cuando do_sample_frames=True.
  • num_frames (Annotated[int | None, None], kwargs) — Número máximo de fotogramas a muestrear cuando do_sample_frames=True.
  • return_metadata (bool, kwargs, opcional) — Si se devuelve o no la metadatos del vídeo. Los metadatos del vídeo son un objeto que contiene información sobre la duración del vídeo, los fps, el backend de decodificación, etc.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Devuelve tensores apilados si se establece en 'pt'; en caso contrario, devuelve una lista de tensores.

Devuelve

~image_processing_base.BatchFeature

  • data (dict) — Diccionario de listas/arrays/tensores devueltos por el método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización.

VivitModel

clase transformers.VivitModel

< >

( config: VivitConfigadd_pooling_layer: bool = True )

Parámetros

  • config (VivitConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
  • add_pooling_layer (bool, opcional, valor predeterminado True) — Si se debe añadir una capa de pooling

El modelo Vivit básico que genera estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( pixel_values: typing.Optional[torch.Tensor] = Noneinterpolate_pos_encoding: bool = Falseattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parámetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando VivitImageProcessor. Consulte VivitImageProcessor.call() para más detalles (processor_class utiliza VivitImageProcessor para procesar las imágenes).
  • interpolate_pos_encoding (bool, opcional, valor predeterminado False) — Si se debe interpolar las codificaciones de posición preentrenadas.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

Devuelve

BaseModelOutputWithPooling o tuple(torch.Tensor)

Un BaseModelOutputWithPooling o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (VivitConfig) y las entradas.

El método forward de VivitModel reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

>>> import av
>>> import numpy as np

>>> from transformers import VivitImageProcessor, VivitModel
>>> 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 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

>>> image_processor = VivitImageProcessor.from_pretrained("google/vivit-b-16x2-kinetics400")
>>> model = VivitModel.from_pretrained("google/vivit-b-16x2-kinetics400")

>>> # prepare video for the model
>>> inputs = image_processor(list(video), return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 3137, 768]

VivitForVideoClassification

clase transformers.VivitForVideoClassification

< >

( config: VivitConfig )

Parámetros

  • config (VivitConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Modelo ViViT Transformer con una cabeza de clasificación de vídeo en la parte superior (una capa lineal sobre el estado oculto final del token [CLS]), por ejemplo, para Kinetics-400.

Tenga en cuenta que es posible realizar el ajuste fino de ViT en imágenes de mayor resolución que aquellas con las que se entrenó, estableciendo interpolate_pos_encoding en True en el forward del modelo. Esto interpolará los embeddings de posición preentrenados a la mayor resolución.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneinterpolate_pos_encoding: bool = False**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ImageClassifierOutput or tuple(torch.Tensor)

Parámetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando VivitImageProcessor. Consulte VivitImageProcessor.call() para más detalles (processor_class utiliza VivitImageProcessor para procesar las imágenes).
  • labels (torch.LongTensor de forma (batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de imágenes. Los índices deben estar en [0, ..., config.num_labels - 1]. Si config.num_labels == 1 se calcula una pérdida de regresión (pérdida de error cuadrático medio), si config.num_labels > 1 se calcula una pérdida de clasificación (entropía cruzada).
  • interpolate_pos_encoding (bool, opcional, valor predeterminado False) — Si se debe interpolar las codificaciones de posición preentrenadas.

Devuelve

ImageClassifierOutput o tuple(torch.Tensor)

Un ImageClassifierOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (VivitConfig) y las entradas.

El método forward de VivitForVideoClassification reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación (o de regresión si config.num_labels==1).

  • logits (torch.Tensor de forma (batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustación, + una para la salida de cada etapa) de forma (batch_size, sequence_length, hidden_size). Estados ocultos (también llamados mapas de características) del modelo en la salida de cada etapa.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, patch_size, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

>>> import av
>>> import numpy as np
>>> import torch

>>> from transformers import VivitImageProcessor, VivitForVideoClassification
>>> 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 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=4, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

>>> image_processor = VivitImageProcessor.from_pretrained("google/vivit-b-16x2-kinetics400")
>>> model = VivitForVideoClassification.from_pretrained("google/vivit-b-16x2-kinetics400")

>>> inputs = image_processor(list(video), return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)
...     logits = outputs.logits

>>> # model predicts one of the 400 Kinetics-400 classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
LABEL_116
Update on GitHub

←VideoPrism ALIGN→