# Video Vision Transformer (ViViT) ## Обзор Модель Vivit была предложена в статье [ViViT: A Video Vision Transformer](https://huggingface.co/papers/2103.15691) авторами Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Lučić, Cordelia Schmid. В статье предлагается один из первых успешных наборов моделей на основе чистых трансформеров для понимания видео. Аннотация из статьи следующая: *Мы представляем модели на основе чистых трансформеров для классификации видео, опираясь на недавний успех подобных моделей в классификации изображений. Наша модель извлекает пространственно-временные токены из входного видео, которые затем кодируются серией трансформерных слоёв. Чтобы обрабатывать длинные последовательности токенов, характерные для видео, мы предлагаем несколько эффективных вариантов нашей модели, которые факторизуют пространственное и временное измерения входа. Хотя известно, что трансформерные модели эффективны только при наличии больших обучающих наборов данных, мы показываем, как можно эффективно регуляризовать модель в процессе обучения и использовать предобученные модели изображений, чтобы обучаться на относительно небольших наборах данных. Мы проводим тщательные исследования абляций и достигаем наилучших результатов на нескольких бенчмарках классификации видео, включая Kinetics 400 и 600, Epic Kitchens, Something-Something v2 и Moments in Time, превосходя предыдущие методы, основанные на глубоких 3D-свёрточных сетях.* Эта модель была предоставлена [jegormeister](https://huggingface.co/jegormeister). Исходный код (написанный на JAX) можно найти [здесь](https://github.com/google-research/scenic/tree/main/scenic/projects/vivit). ### Использование масштабированного внимания на основе скалярного произведения (SDPA) PyTorch включает в себя нативный оператор масштабированного внимания на основе скалярного произведения (SDPA) в составе `torch.nn.functional`. Эта функция объединяет несколько реализаций, которые могут применяться в зависимости от входных данных и используемого оборудования. Подробнее см. в [официальной документации](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) или на странице [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention). SDPA используется по умолчанию для `torch>=2.1.1`, когда доступна соответствующая реализация, но вы также можете установить `attn_implementation="sdpa"` в `from_pretrained()`, чтобы явно запросить использование SDPA. ```python from transformers import VivitModel model = VivitModel.from_pretrained("google/vivit-b-16x2-kinetics400", attn_implementation="sdpa", device_map="auto") ... ``` Для достижения максимального ускорения мы рекомендуем загружать модель в половинной точности (например, `torch.float16` или `torch.bfloat16`). На локальном бенчмарке (A100-40GB, PyTorch 2.3.0, ОС Ubuntu 22.04) с `float32` и моделью `google/vivit-b-16x2-kinetics400` мы наблюдали следующее ускорение во время инференса. ### Обучение | num_training_steps | batch_size | is cuda | Ускорение (%) | Пиковая память Eager (МБ) | sdpa пиковая память (МБ) | Экономия памяти (%) | |---------------------:|-------------:|----------:|--------------:|----------------------:|---------------------:|-----------------:| | 100 | 1 | True | 7.122 | 2575.28 | 5932.54 | 130.364 | ### Вывод | num_batches | batch_size | is cuda | is half | Ускорение (%) | Mem eager (МБ) | Память BT (МБ) | Сэкономлено памяти (%) | |---------------|--------------|-----------|-----------|---------------|------------------|---------------|-----------------| | 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') ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/configuration_vivit.py#L24) **Параметры:** image_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `224`) : Размер (разрешение) каждого изображения. num_frames (`int`, *необязательный*, по умолчанию 32) : Количество кадров в каждом видео. tubelet_size (`list[int]`, *необязательный*, по умолчанию `[2, 16, 16]`) : Размер (разрешение) каждого tubelet. num_channels (`int`, *необязательный*, по умолчанию `3`) : Количество входных каналов. hidden_size (`int`, *optional*, по умолчанию `768`) : Размерность скрытых представлений. num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer. num_attention_heads (`int`, *необязательный*, по умолчанию `12`) : Количество головок внимания для каждого слоя внимания в декодере Transformer. intermediate_size (`int`, *optional*, по умолчанию `3072`) : Размерность представлений MLP. hidden_act (`str`, *необязательный*, по умолчанию `gelu_fast`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. hidden_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Вероятность dropout для всех полносвязных слоёв в эмбеддингах, энкодере и пулере. attention_probs_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.0`) : Коэффициент dropout для вероятностей внимания. initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-06`) : Значение epsilon, используемое слоями нормализации. qkv_bias (`bool`, *необязательный*, по умолчанию `True`) : Добавлять ли смещение (bias) к запросам, ключам и значениям. pooler_output_size (`int`, *optional*) : Размерность слоя пулинга. Если None, по умолчанию используется `hidden_size`. pooler_act (`str`, *необязательный*, по умолчанию `"tanh"`) : Функция активации, используемая пуллером. Это класс конфигурации для хранения настроек модели VivitModel. Он используется для создания модели Vivit в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [google/vivit-b-16x2-kinetics400](https://huggingface.co/google/vivit-b-16x2-kinetics400) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/image_processing_vivit.py#L63) **Параметры:** do_resize (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли изменить размеры изображения (высота, ширина) до заданного значения `size`. Может быть переопределено параметром `do_resize` в методе `preprocess`. size (`dict[str, int]` *необязательный*, по умолчанию `{"shortest_edge" : 256}`): размер выходного изображения после изменения масштаба. Короткая сторона изображения будет изменена до `size["shortest_edge"]` с сохранением соотношения сторон исходного изображения. Может быть переопределён параметром `size` в методе `preprocess`. resample (`PILImageResampling`, *необязательный*, по умолчанию `Resampling.BILINEAR`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть переопределён параметром `resample` в методе `preprocess`. do_center_crop (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли выполнять центрированное обрезание изображения до заданного размера `crop_size`. Может быть переопределено параметром `do_center_crop` в методе `preprocess`. crop_size (`dict[str, int]`, *необязательный*, по умолчанию `{"height" : 224, "width": 224}`): Размер изображения после применения центрального кадрирования. Может быть переопределён параметром `crop_size` в методе `preprocess`. do_rescale (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли масштабировать изображение с помощью заданного коэффициента `rescale_factor`. Может быть переопределено параметром `do_rescale` в методе `preprocess`. rescale_factor (`int` или `float`, *необязательный*, по умолчанию `1/127.5`) : Определяет коэффициент масштабирования, используемый при перемасштабировании изображения. Может быть переопределён параметром `rescale_factor` в методе `preprocess`. offset (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли масштабировать изображение как в отрицательном, так и в положительном направлениях. Может быть переопределено параметром `offset` в методе `preprocess`. do_normalize (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли нормализовать изображение. Может быть переопределено параметром `do_normalize` в методе `preprocess`. image_mean (`float` или `list[float]`, *необязательный*, по умолчанию `IMAGENET_STANDARD_MEAN`) : Среднее значение, используемое при нормализации изображения. Это число с плавающей точкой или список таких чисел, длина которого равна количеству каналов в изображении. Может быть переопределено параметром `image_mean` в методе `preprocess`. image_std (`float` или `list[float]`, *необязательный*, по умолчанию `IMAGENET_STANDARD_STD`) : Стандартное отклонение, используемое при нормализации изображения. Это число с плавающей точкой или список таких чисел, длина которого равна количеству каналов в изображении. Может быть переопределено параметром `image_std` в методе `preprocess`. Создает процессор изображений 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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/image_processing_vivit.py#L285) **Параметры:** videos (`ImageInput`) : Кадры видео для предобработки. Ожидается один кадр или пакет кадров видео со значениями пикселей в диапазоне от 0 до 255. Если передаются кадры со значениями пикселей от 0 до 1, установите `do_rescale=False`. do_resize (`bool`, *необязательный*, по умолчанию `self.do_resize`) : Нужно ли изменять размер изображения. size (`dict[str, int]`, *необязательный*, по умолчанию `self.size`) : Размер изображения после применения масштабирования. resample (`PILImageResampling`, *необязательный*, по умолчанию `self.resample`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Влияет только в том случае, если `do_resize` установлено в `True`. do_center_crop (`bool`, *необязательный*, по умолчанию `self.do_centre_crop`) : Нужно ли выполнять центрированный кроп изображения. crop_size (`dict[str, int]`, *необязательный*, по умолчанию `self.crop_size`) : Размер изображения после применения центрального кадрирования. do_rescale (`bool`, *необязательный*, по умолчанию `self.do_rescale`) : Нужно ли масштабировать значения изображения в диапазон `[-1 - 1]`, если `offset` равен `True`, иначе в диапазон `[0, 1]`. rescale_factor (`float`, *необязательный*, по умолчанию `self.rescale_factor`) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`. offset (`bool`, *необязательный*, по умолчанию `self.offset`) : Указывает, следует ли масштабировать изображение в обоих направлениях — как в отрицательную, так и в положительную сторону. do_normalize (`bool`, *необязательный*, по умолчанию `self.do_normalize`) : Нужно ли нормализовать изображение. image_mean (`float` или `list[float]`, *необязательный*, по умолчанию `self.image_mean`) : Среднее значение изображения. image_std (`float` или `list[float]`, *необязательный*, по умолчанию `self.image_std`) : Стандартное отклонение изображения. return_tensors (`str` или `TensorType`, *необязательный*) : Тип возвращаемых тензоров. Может быть одним из: - Не задано: возвращает список `np.ndarray`. - `TensorType.PYTORCH` или `'pt'`: возвращает батч типа `torch.Tensor`. - `TensorType.NUMPY` или `'np'`: возвращает батч типа `np.ndarray`. data_format (`ChannelDimension` или `str`, *необязательный*, по умолчанию `ChannelDimension.FIRST`) : Формат размерности каналов для выходного изображения. Может быть одним из: - `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - Не задано: Использовать выведенный формат размерности каналов входного изображения. input_data_format (`ChannelDimension` или `str`, *необязательный*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width). Предобработка изображения или пакета изображений. ## VivitVideoProcessor[[transformers.VivitVideoProcessor]] #### transformers.VivitVideoProcessor[[transformers.VivitVideoProcessor]] ```python transformers.VivitVideoProcessor(**kwargs: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/video_processing_vivit.py#L25) **Параметры:** do_convert_rgb (`bool`, *kwargs*, *необязательный*, по умолчанию `True`) : Преобразовать ли изображение в RGB. do_resize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли изменять размер изображения. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'shortest_edge' : 256}`): описывает максимальные размеры входных данных для модели. default_to_square (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Использовать ли квадратное изображение по умолчанию при изменении размера, если size является int. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, по умолчанию `2`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только если `do_resize` установлено в `True`. do_rescale (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли масштабировать изображение. rescale_factor (`float`, *kwargs*, *optional*, по умолчанию `0.00784313725490196`) : Коэффициент масштабирования для изменения масштаба изображения, если `do_rescale` установлен в `True`. do_normalize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли нормализовать изображение. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.5, 0.5, 0.5]`) : Средние значения изображения для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.5, 0.5, 0.5]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. do_center_crop (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли выполнять центрированный кроп изображения. do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'height' : 224, 'width': 224}`): Размер выходного изображения после применения `center_crop`. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео. do_sample_frames (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Нужно ли выбирать кадры из видео перед обработкой или обрабатывать всё видео целиком. video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Метаданные видео, содержащие информацию о общей длительности, fps и общем количестве кадров. Будут использоваться для выборки кадров из видео или вычисления временных меток. Не передавайте метаданные, если вы не пытаетесь декодировать видео вручную перед обработкой fps (`Annotated[int | float | None, None]`, *kwargs*) : Целевое количество кадров для выборки в секунду при `do_sample_frames=True`. num_frames (`Annotated[int | None, None]`, *kwargs*) : Максимальное количество кадров для выборки при `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *optional*, по умолчанию `False`) : Нужно ли возвращать метаданные видео. Метаданные видео — это объект, содержащий информацию о длительности видео, частоте кадров, бэкенде декодирования и т. д. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения: - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy. - ****kwargs** ([VideosKwargs](/docs/transformers/main/ru/main_classes/processors#transformers.VideosKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict. Создаёт видеопроцессор 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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/video_processing_vivit.py#L49) **Параметры:** 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]]]`) : Видео для предобработки. Ожидается одно видео или батч видео со значениями пикселей в диапазоне от 0 до 255. Если передаются видео со значениями пикселей от 0 до 1, установите `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *необязательный*) : Преобразовать ли изображение в RGB. do_resize (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли изменить размер изображения. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Описывает максимальные размеры входных данных для модели. default_to_square (`bool`, *kwargs*, *необязательный*) : Указывает, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задан как int. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только при установке `do_resize` в `True`. do_rescale (`bool`, *kwargs*, *необязательный*) : Нужно ли масштабировать изображение. rescale_factor (`float`, *kwargs*, *optional*) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`. do_normalize (`bool`, *kwargs*, *необязательный*) : Нужно ли нормализовать изображение. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Среднее значение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке. do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео. do_sample_frames (`bool`, *kwargs*, *optional*) : Нужно ли выбирать кадры из видео перед обработкой или обрабатывать всё видео целиком. video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Метаданные видео, содержащие информацию о общей длительности, fps и общем количестве кадров. Будут использоваться для выборки кадров из видео или вычисления временных меток. Не передавайте метаданные, если вы не пытаетесь декодировать видео вручную перед обработкой fps (`Annotated[int | float | None, None]`, *kwargs*) : Целевое количество кадров для выборки в секунду при `do_sample_frames=True`. num_frames (`Annotated[int | None, None]`, *kwargs*) : Максимальное количество кадров для выборки при `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *optional*) : Нужно ли возвращать метаданные видео. Метаданные видео — это объект, содержащий информацию о длительности видео, частоте кадров, бэкенде декодирования и т. д. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Возвращает стопку тензоров, если установлено значение `'pt'`, иначе возвращает список тензоров. **Возвращает:** `~image_processing_base.BatchFeature` - **data** (`dict`) — Словарь списков/массивов/тензоров, возвращаемый методом __call__ ('pixel_values' и т. д.). - **tensor_type** (`Union[None, str, TensorType]`, *необязательный*) -- Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy. ## VivitModel[[transformers.VivitModel]] #### transformers.VivitModel[[transformers.VivitModel]] ```python transformers.VivitModel(config: VivitConfig, add_pooling_layer: bool = True) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L318) **Параметры:** config ([VivitConfig](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. add_pooling_layer (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли добавлять слой пулинга Модель Vivit без дополнительных слоёв, выводящая необработанные скрытые состояния. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### 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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L333) **Параметры:** pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [VivitImageProcessor](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitImageProcessor). Подробности см. в [VivitImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [VivitImageProcessor](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitImageProcessor) для обработки изображений). interpolate_pos_encoding (`bool`, *необязательный*, по умолчанию `False`) : Интерполировать ли предобученные позиционные кодирования. attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) **Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)` Объект [BaseModelOutputWithPooling](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([VivitConfig](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitConfig)) и входных данных. Метод forward модели [VivitModel](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L447) **Параметры:** config ([VivitConfig](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель ViViT Transformer с головной частью для классификации видео (линейный слой поверх финального скрытого состояния токена [CLS]), например, для Kinetics-400. Обратите внимание, что ViT можно дообучать на изображениях с более высоким разрешением, чем те, на которых он обучался, установив `interpolate_pos_encoding` в `True` в forward модели. Это позволит интерполировать предобученные позиционные эмбеддинги до более высокого разрешения. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### 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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vivit/modeling_vivit.py#L460) **Параметры:** pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательно*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [VivitImageProcessor](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitImageProcessor). Подробности см. в [VivitImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [VivitImageProcessor](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitImageProcessor) для обработки изображений). labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления потерь классификации/регрессии изображений. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется потеря регрессии (среднеквадратичная потеря), если `config.num_labels > 1`, вычисляется потеря классификации (кросс-энтропия). interpolate_pos_encoding (`bool`, *необязательный*, по умолчанию `False`) : Интерполировать ли предобученные позиционные кодирования. **Возвращает:** [ImageClassifierOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) или `tuple(torch.Tensor)` Объект [ImageClassifierOutput](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.ImageClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([VivitConfig](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitConfig)) и входных данных. Метод [VivitForVideoClassification](/docs/transformers/main/ru/model_doc/vivit#transformers.VivitForVideoClassification) forward переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1). - **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) — Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет такой слой, + один для вывода каждого этапа) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния (также называемые картами признаков) модели на выходе каждого этапа. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, patch_size, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```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 ```