# Video Vision Transformer (ViViT) ## Resumen El modelo Vivit se propuso en [ViViT: A Video Vision Transformer](https://huggingface.co/papers/2103.15691) de Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Lučić y Cordelia Schmid. El artículo propone uno de los primeros conjuntos de modelos basados puramente en transformers que tuvieron éxito en 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](https://huggingface.co/jegormeister). El código original (escrito en JAX) se puede encontrar [aquí](https://github.com/google-research/scenic/tree/main/scenic/projects/vivit). ### Uso de la atención de producto escalar de puntos (SDPA) PyTorch incluye un operador nativo de atención de producto punto escalado (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](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) o la página [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) 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. ```python 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_steps | batch_size | es cuda | Aceleración (%) | Memoria pico eager (MB) | mem. pico de sdpa (MB) | Ahorro de memoria (%) | |---------------------:|-------------:|----------:|--------------:|----------------------:|---------------------:|-----------------:| | 100 | 1 | True | 7.122 | 2575.28 | 5932.54 | 130.364 | ### Inferencia | num_batches | batch_size | es cuda | es la mitad | Aceleración (%) | Memoria eager (MB) | Mem BT (MB) | Memoria guardada (%) | |---------------|--------------|-----------|-----------|---------------|------------------|---------------|-----------------| | 20 | 1 | True | False | 15.422 | 715.807 | 317.079 | 125.75 | | 20 | 2 | True | False | 17.146 | 1234.75 | 447.175 | 176.122 | | 20 | 4 | True | False | 18.093 | 2275.82 | 709.864 | 220.6 | | 20 | 8 | True | False | 19.284 | 4358.19 | 1233.24 | 253.393 | ## VivitConfig[[transformers.VivitConfig]] #### transformers.VivitConfig[[transformers.VivitConfig]] ```python transformers.VivitConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, image_size: int | list[int] | tuple[int, int] = 224, num_frames: int = 32, tubelet_size: list[int] | tuple[int, ...] = (2, 16, 16), num_channels: int = 3, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu_fast', hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, qkv_bias: bool = True, pooler_output_size: int | None = None, pooler_act: str = 'tanh') ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/configuration_vivit.py#L24) **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 en cada video. 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 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 completamente conectadas en los embeddings, 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 de truncated_normal_initializer para inicializar todas las matrices de pesos. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. qkv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica 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](https://huggingface.co/google/vivit-b-16x2-kinetics400) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> 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[[transformers.VivitImageProcessor]] #### transformers.VivitImageProcessor[[transformers.VivitImageProcessor]] ```python transformers.VivitImageProcessor(do_resize: bool = True, size: dict[str, int] | None = None, resample: Resampling = , do_center_crop: bool = True, crop_size: dict[str, int] | None = None, do_rescale: bool = True, rescale_factor: int | float = 0.00784313725490196, offset: bool = True, do_normalize: bool = True, image_mean: float | list[float] | None = None, image_std: float | list[float] | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/image_processing_vivit.py#L63) **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 sobrescribirse mediante `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 anulado 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. Se puede sobrescribir mediante el parámetro `do_center_crop` en el 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` en el 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. Se puede anular 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 ser sobrescrito por el parámetro `image_mean` en el 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. #### preprocess[[transformers.VivitImageProcessor.preprocess]] ```python preprocess(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 = None, size: dict[str, int] | None = None, resample: PIL.Image.Resampling | None = None, do_center_crop: bool | None = None, crop_size: dict[str, int] | None = None, do_rescale: bool | None = None, rescale_factor: float | None = None, offset: bool | None = None, do_normalize: bool | None = None, image_mean: float | list[float] | None = None, image_std: float | list[float] | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, data_format: ChannelDimension = , input_data_format: str | transformers.image_utils.ChannelDimension | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/image_processing_vivit.py#L285) **Parámetros:** videos (`ImageInput`) : Marcos de video para preprocesar. Espera un único lote o un lote de marcos de video con valores de píxeles que van de 0 a 255. Si se pasan marcos 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 centrada. 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*, por defecto `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*, valor predeterminado `self.rescale_factor`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. offset (`bool`, *opcional*, valor predeterminado `self.offset`) : Si se escala 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: - Sin establecer: 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*, valor predeterminado `ChannelDimension.FIRST`) : El formato de la dimensión de canal para la imagen de salida. Puede ser uno de los siguientes: - `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - Sin establecer: usa el formato de la 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 los siguientes: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). Preprocesa una imagen o un lote de imágenes. ## VivitVideoProcessor[[transformers.VivitVideoProcessor]] #### transformers.VivitVideoProcessor[[transformers.VivitVideoProcessor]] ```python transformers.VivitVideoProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/video_processing_vivit.py#L25) **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 máximas de entrada para el modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando size es un int. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : 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_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica 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` está establecido 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 canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal 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 (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. do_sample_frames (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Indica 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 pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos 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 video. Los metadatos del video son un objeto que contiene información sobre la duración del video, 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](/docs/transformers/main/es/main_classes/processors#transformers.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. #### preprocess[[transformers.VivitVideoProcessor.preprocess]] ```python preprocess(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: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/video_processing_vivit.py#L49) **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]]]`) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `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 máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 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_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 canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal 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 (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. do_sample_frames (`bool`, *kwargs*, *opcional*) : Indica si se deben muestrear fotogramas del vídeo antes de procesarlo o si se debe procesar el vídeo 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 pases ningún metadato a menos que estés intentando decodificar el video manualmente antes de procesarlo fps (`Annotated[int | float | None, None]`, *kwargs*) : Marcos 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*) : Indica si se debe devolver o no los 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[[transformers.VivitModel]] #### transformers.VivitModel[[transformers.VivitModel]] ```python transformers.VivitModel(config: VivitConfig, add_pooling_layer: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L318) **Parámetros:** config ([VivitConfig](/docs/transformers/main/es/model_doc/vivit#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.VivitModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L333) **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 usando [VivitImageProcessor](/docs/transformers/main/es/model_doc/vivit#transformers.VivitImageProcessor). Consulte [VivitImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [VivitImageProcessor](/docs/transformers/main/es/model_doc/vivit#transformers.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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/vivit#transformers.VivitConfig)) y las entradas. El método forward de [VivitModel](/docs/transformers/main/es/model_doc/vivit#transformers.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 preprocesamiento y posprocesamiento, 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*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + 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: ```python >>> 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[[transformers.VivitForVideoClassification]] #### transformers.VivitForVideoClassification[[transformers.VivitForVideoClassification]] ```python transformers.VivitForVideoClassification(config: VivitConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L447) **Parámetros:** config ([VivitConfig](/docs/transformers/main/es/model_doc/vivit#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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 las utilizadas en su entrenamiento, 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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.VivitForVideoClassification.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L460) **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 usando [VivitImageProcessor](/docs/transformers/main/es/model_doc/vivit#transformers.VivitImageProcessor). Consulte [VivitImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [VivitImageProcessor](/docs/transformers/main/es/model_doc/vivit#transformers.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 imagen. 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](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) o `tuple(torch.Tensor)` Un [ImageClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/vivit#transformers.VivitConfig)) y las entradas. El método forward de [VivitForVideoClassification](/docs/transformers/main/es/model_doc/vivit#transformers.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 preprocesamiento y posprocesamiento, 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 los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada etapa) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (también llamados feature maps) 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: ```python >>> 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 ```