# VideoMAE ## Resumen El modelo VideoMAE fue propuesto en [VideoMAE: Masked Autoencoders are Data-Efficient Learners for Self-Supervised Video Pre-Training](https://huggingface.co/papers/2203.12602) por Zhan Tong, Yibing Song, Jue Wang y Limin Wang. VideoMAE extiende los auto codificadores enmascarados ([MAE](vit_mae)) al video, y afirma un rendimiento de última generación en varios benchmarks de clasificación de video. El resumen del artículo es el siguiente: *El preentrenamiento de transformadores de video en conjuntos de datos de escala muy grande es generalmente necesario para lograr un rendimiento destacado en conjuntos de datos relativamente pequeños. En este artículo, demostramos que los auto codificadores enmascarados de video (VideoMAE) son aprendices eficientes en el uso de datos para el preentrenamiento auto supervisado de video (SSVP). Nos inspiramos en el reciente ImageMAE y proponemos un enmascaramiento y una reconstrucción de tubos de video personalizados. Estos diseños simples resultan ser efectivos para superar la fuga de información causada por la correlación temporal durante la reconstrucción de video. Obtenemos tres hallazgos importantes sobre SSVP: (1) Una proporción de enmascaramiento extremadamente alta (es decir, del 90% al 95%) aún produce un rendimiento favorable de VideoMAE. El contenido de video temporalmente redundante permite una proporción de enmascaramiento mayor que la de las imágenes. (2) VideoMAE logra resultados impresionantes en conjuntos de datos muy pequeños (es decir, alrededor de 3k-4k videos) sin utilizar datos adicionales. Esto se atribuye en parte a la tarea desafiante de la reconstrucción de video, que fuerza el aprendizaje de estructuras de alto nivel. (3) VideoMAE demuestra que la calidad de los datos es más importante que la cantidad de datos para SSVP. El cambio de dominio entre los conjuntos de datos de preentrenamiento y los conjuntos de datos objetivo son problemas importantes en SSVP. Cabe destacar que nuestro VideoMAE con el backbone ViT estándar puede lograr un 83,9% en Kinects-400, un 75,3% en Something-Something V2, un 90,8% en UCF101 y un 61,1% en HMDB51 sin utilizar datos adicionales.* drawing Preentrenamiento de VideoMAE. Tomado del artículo original. Este modelo fue aportado por [nielsr](https://huggingface.co/nielsr). El código original se puede encontrar [aquí](https://github.com/MCG-NJU/VideoMAE). ## 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 VideoMAEForVideoClassification model = VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics", 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 `MCG-NJU/videomae-base-finetuned-kinetics`, observamos las siguientes aceleraciones durante la inferencia. | Tamaño del lote | Tiempo medio de inferencia (ms), modo eager | Tiempo medio de inferencia (ms), modelo sdpa | Acelerar, Sdpa / Eager (x) | |--------------|-------------------------------------------|-------------------------------------------|------------------------------| | 1 | 37 | 10 | 3.7 | | 2 | 24 | 18 | 1.33 | | 4 | 43 | 32 | 1.34 | | 8 | 84 | 60 | 1.4 | ## Recursos Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar con VideoMAE. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente. **Clasificación de video** - [Un cuaderno](https://github.com/huggingface/notebooks/blob/main/examples/video_classification.ipynb) que muestra cómo para ajustar un modelo de VideoMAE en un conjunto de datos personalizado. - [Guía de la tarea de clasificación de video](../tasks/video_classification) - [Un Space de 🤗](https://huggingface.co/spaces/sayakpaul/video-classification-ucf101-subset) que muestra cómo realizar inferencia con un modelo de clasificación de video. ## VideoMAEConfig[[transformers.VideoMAEConfig]] #### transformers.VideoMAEConfig[[transformers.VideoMAEConfig]] ```python transformers.VideoMAEConfig(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, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, num_frames: int = 16, tubelet_size: int = 2, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', 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-12, qv_bias: bool = True, use_mean_pooling: bool = True, decoder_num_attention_heads: int = 6, decoder_hidden_size: int = 384, decoder_num_hidden_layers: int = 4, decoder_intermediate_size: int = 1536, norm_pix_loss: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/configuration_videomae.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. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `16`) : El tamaño (resolución) de cada parche. num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada. num_frames (`int`, *opcional*, valor predeterminado 16) : El número de fotogramas de cada video. tubelet_size (`int`, *opcional*, valor predeterminado 2) : El número de tubelets. 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`) : 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-12`) : El epsilon utilizado por las capas de normalización de capas. qv_bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir un sesgo a las consultas y valores en las capas de autoatención. use_mean_pooling (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar un promedio de las últimas capas ocultas en lugar de utilizar el último estado oculto del token [CLS]. decoder_num_attention_heads (`int`, *opcional*, valor predeterminado 6) : Número de cabezas de atención para cada capa de atención en el decodificador. decoder_hidden_size (`int`, *opcional*, valor predeterminado 384) : Dimensionalidad del decodificador. decoder_num_hidden_layers (`int`, *opcional*, valor predeterminado 4) : Número de capas ocultas en el decodificador. decoder_intermediate_size (`int`, *opcional*, valor predeterminado 1536) : Dimensionalidad de la capa "intermedia" (es decir, de retroalimentación) en el decodificador. norm_pix_loss (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben normalizar los píxeles del parche objetivo. Esta es la clase de configuración para almacenar la configuración de un VideoMAEModel. Se utiliza para instanciar un modelo Videomae 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 [MCG-NJU/videomae-base](https://huggingface.co/MCG-NJU/videomae-base) 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 VideoMAEConfig, VideoMAEModel >>> # Initializing a VideoMAE videomae-base style configuration >>> configuration = VideoMAEConfig() >>> # Randomly initializing a model from the configuration >>> model = VideoMAEModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## VideoMAEImageProcessor[[transformers.VideoMAEImageProcessor]] #### transformers.VideoMAEImageProcessor[[transformers.VideoMAEImageProcessor]] ```python transformers.VideoMAEImageProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/image_processing_videomae.py#L35) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : 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' : 224}`): 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. 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`. 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.00392156862745098`) : 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_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. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe recortar la imagen centrada. 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. 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. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. Construye un procesador de imágenes VideoMAEImageProcessor. #### preprocess[[transformers.VideoMAEImageProcessor.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']], **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/image_processing_videomae.py#L53) **Parámetros:** videos (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Video o lote de videos para preprocesar. Espera un único video (lista de fotogramas) o un lote de videos (lista de listas de fotogramas). Cada fotograma puede ser una imagen PIL, un array de numpy o un tensor de torch 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_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. 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`. 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_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. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. 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. 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. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. **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. ## VideoMAEImageProcessorPil[[transformers.VideoMAEImageProcessorPil]] #### transformers.VideoMAEImageProcessorPil[[transformers.VideoMAEImageProcessorPil]] ```python transformers.VideoMAEImageProcessorPil(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/image_processing_pil_videomae.py#L33) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : 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' : 224}`): 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. 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`. 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.00392156862745098`) : 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_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. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe recortar la imagen centrada. 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. 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. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. Construye un procesador de imágenes VideoMAEImageProcessor. #### preprocess[[transformers.VideoMAEImageProcessorPil.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']], **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/image_processing_pil_videomae.py#L51) **Parámetros:** videos (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Video o lote de videos para preprocesar. Espera un único video (lista de fotogramas) o un lote de videos (lista de listas de fotogramas). Cada fotograma puede ser una imagen PIL, un array de numpy o un tensor de torch 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_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. 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`. 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_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. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. 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. 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. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. **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. ## VideoMAEVideoProcessor[[transformers.VideoMAEVideoProcessor]] #### transformers.VideoMAEVideoProcessor[[transformers.VideoMAEVideoProcessor]] ```python transformers.VideoMAEVideoProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/video_processing_videomae.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' : 224}`): 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.00392156862745098`) : 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 VideoMAEVideoProcessor. #### preprocess[[transformers.VideoMAEVideoProcessor.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/videomae/video_processing_videomae.py#L41) **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. ## VideoMAEModel[[transformers.VideoMAEModel]] #### transformers.VideoMAEModel[[transformers.VideoMAEModel]] ```python transformers.VideoMAEModel(config: VideoMAEConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/modeling_videomae.py#L398) **Parámetros:** config ([VideoMAEConfig](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEConfig)) : 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. El modelo Videomae básico que emite 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.VideoMAEModel.forward]] ```python forward(pixel_values: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/modeling_videomae.py#L417) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [VideoMAEImageProcessor](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEImageProcessor). Consulte [VideoMAEImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [VideoMAEImageProcessor](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEImageProcessor) para procesar imágenes). bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Posiciones enmascaradas booleanas. Indica qué parches están enmascarados (1) y cuáles no (0). Cada vídeo del lote debe tener el mismo número de parches enmascarados. Si es `None`, se consideran todos los parches. La longitud de la secuencia es `(num_frames // tubelet_size) * (image_size // patch_size) ** 2`. **Devuelve:** [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o `tuple(torch.Tensor)` Un [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 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 ([VideoMAEConfig](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEConfig)) y las entradas. El método forward de [VideoMAEModel](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEModel) 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. - **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 torch >>> from transformers import VideoMAEVideoProcessor, VideoMAEModel >>> from huggingface_hub import hf_hub_download >>> # replace this with your own video file >>> video_path = hf_hub_download( ... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset" ... ) >>> video_processor = VideoMAEVideoProcessor.from_pretrained("MCG-NJU/videomae-base") >>> model = VideoMAEModel.from_pretrained("MCG-NJU/videomae-base") >>> # prepare video for the model >>> inputs = video_processor(video_path, return_tensors="pt") >>> # forward pass >>> with torch.no_grad(): ... outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state >>> list(last_hidden_states.shape) [1, 1568, 768] ``` ## VideoMAEForPreTraining[[transformers.VideoMAEForPreTraining]] `VideoMAEForPreTraining` incluye el decodificador en la parte superior para el preentrenamiento auto-supervisado. #### transformers.VideoMAEForPreTraining[[transformers.VideoMAEForPreTraining]] ```python transformers.VideoMAEForPreTraining(config: VideoMAEConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/modeling_videomae.py#L511) **Parámetros:** config ([VideoMAEConfig](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEConfig)) : 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. El transformer del modelo VideoMAE con el decodificador en la parte superior para el preentrenamiento auto-supervisado. 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.VideoMAEForPreTraining.forward]] ```python forward(pixel_values: Tensor, bool_masked_pos: BoolTensor, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/modeling_videomae.py#L529) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [VideoMAEImageProcessor](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEImageProcessor). Consulte [VideoMAEImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [VideoMAEImageProcessor](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEImageProcessor) para procesar imágenes). bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, sequence_length)`) : Posiciones enmascaradas booleanas. Indica qué parches están enmascarados (1) y cuáles no (0). Cada vídeo del lote debe tener el mismo número de parches enmascarados. La longitud de la secuencia es `(num_frames // tubelet_size) * (image_size // patch_size) ** 2`. **Devuelve:** `VideoMAEForPreTrainingOutput` o `tuple(torch.Tensor)` Un `VideoMAEForPreTrainingOutput` 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 ([VideoMAEConfig](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEConfig)) y las entradas. El método forward de [VideoMAEForPreTraining](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEForPreTraining) 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,)`) -- Pérdida de reconstrucción de píxeles. - **logits** (`torch.Tensor` de forma `(batch_size, patch_size ** 2 * num_channels)`) -- Logits de reconstrucción de píxeles. - **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 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: ```python >>> from transformers import AutoImageProcessor, VideoMAEForPreTraining >>> import numpy as np >>> import torch >>> num_frames = 16 >>> video = list(np.random.randint(0, 256, (num_frames, 3, 224, 224))) >>> image_processor = AutoImageProcessor.from_pretrained("MCG-NJU/videomae-base") >>> model = VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base") >>> pixel_values = image_processor(video, return_tensors="pt").pixel_values >>> num_patches_per_frame = (model.config.image_size // model.config.patch_size) ** 2 >>> seq_length = (num_frames // model.config.tubelet_size) * num_patches_per_frame >>> bool_masked_pos = torch.randint(0, 2, (1, seq_length)).bool() >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos) >>> loss = outputs.loss ``` ## VideoMAEForVideoClassification[[transformers.VideoMAEForVideoClassification]] #### transformers.VideoMAEForVideoClassification[[transformers.VideoMAEForVideoClassification]] ```python transformers.VideoMAEForVideoClassification(config: VideoMAEConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/modeling_videomae.py#L684) **Parámetros:** config ([VideoMAEConfig](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEConfig)) : 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 transformer de VideoMAE con una cabeza de clasificación de vídeo en la parte superior (una capa lineal sobre los estados ocultos promediados de todos los tokens), por ejemplo, para ImageNet. 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.VideoMAEForVideoClassification.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/videomae/modeling_videomae.py#L698) **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 mediante [VideoMAEImageProcessor](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEImageProcessor). Consulte [VideoMAEImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles (`processor_class` utiliza [VideoMAEImageProcessor](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEImageProcessor) 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). **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 ([VideoMAEConfig](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEConfig)) y las entradas. El método forward de [VideoMAEForVideoClassification](/docs/transformers/main/es/model_doc/videomae#transformers.VideoMAEForVideoClassification) 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 torch >>> from transformers import VideoMAEVideoProcessor, VideoMAEForVideoClassification >>> from huggingface_hub import hf_hub_download >>> # replace this with your own video file >>> video_path = hf_hub_download( ... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset" ... ) >>> video_processor = VideoMAEVideoProcessor.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics") >>> model = VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics") >>> inputs = video_processor(video_path, 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]) eating spaghetti ```