Este modelo foi publicado no HF papers em 2021-03-29 e contribuído para o Hugging Face Transformers em 2023-07-11.

Video Vision Transformer (ViViT)

Visão geral

O modelo Vivit foi proposto em ViViT: A Video Vision Transformer por Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Lučić, Cordelia Schmid. O artigo propõe um dos primeiros conjuntos de modelos baseados puramente em transformers com sucesso para compreensão de vídeo.

O resumo do artigo é o seguinte:

Apresentamos modelos baseados puramente em transformers para classificação de vídeo, aproveitando o recente sucesso desses modelos na classificação de imagens. Nosso modelo extrai tokens espaço-temporais do vídeo de entrada, que são então codificados por uma série de camadas de transformer. Para lidar com as longas sequências de tokens encontradas em vídeos, propomos várias variantes eficientes do nosso modelo que fatorizam as dimensões espacial e temporal da entrada. Embora seja conhecido que modelos baseados em transformers são eficazes apenas quando grandes conjuntos de dados de treinamento estão disponíveis, mostramos como podemos regularizar eficazmente o modelo durante o treinamento e aproveitar modelos de imagem pré-treinados para treinar em conjuntos de dados relativamente pequenos. Realizamos estudos de ablação detalhados e alcançamos resultados de estado da arte em vários benchmarks de classificação de vídeo, incluindo Kinetics 400 e 600, Epic Kitchens, Something-Something v2 e Moments in Time, superando métodos anteriores baseados em redes convolucionais 3D profundas.

Este modelo foi contribuído por jegormeister. O código original (escrito em JAX) pode ser encontrado aqui.

Usando Scaled Dot Product Attention (SDPA)

O PyTorch inclui um operador nativo de atenção de produto escalar com escala (SDPA) como parte de torch.nn.functional. Essa função abrange várias implementações que podem ser aplicadas dependendo das entradas e do hardware em uso. Consulte a documentação oficial ou a página GPU Inference para mais informações.

O SDPA é usado por padrão para torch>=2.1.1 quando uma implementação está disponível, mas você também pode definir attn_implementation="sdpa" em from_pretrained() para solicitar explicitamente o uso do SDPA.

from transformers import VivitModel


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

Para obter as melhores acelerações, recomendamos carregar o modelo em meia precisão (por exemplo, torch.float16 ou torch.bfloat16).

Em um benchmark local (A100-40GB, PyTorch 2.3.0, sistema operacional Ubuntu 22.04) com float32 e o modelo google/vivit-b-16x2-kinetics400, observamos os seguintes aumentos de velocidade durante a inferência.

Treinamento

num_training_steps	batch_size	é cuda	Aceleração (%)	Memória de pico Eager (MB)	mem. pico do sdpa (MB)	Economia de memória (%)
100	1	True	7.122	2575.28	5932.54	130.364

Inferência

num_batches	batch_size	é cuda	é metade	Aceleração (%)	Memória eager (MB)	Mem BT (MB)	Memória salva (%)
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

classe transformers.VivitConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneimage_size: int | list[int] | tuple[int, int] = 224num_frames: int = 32tubelet_size: list[int] | tuple[int, ...] = (2, 16, 16)num_channels: int = 3hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu_fast'hidden_dropout_prob: float | int = 0.0attention_probs_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06qkv_bias: bool = Truepooler_output_size: int | None = Nonepooler_act: str = 'tanh' )

Parâmetros

image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 224) — O tamanho (resolução) de cada imagem.
num_frames (int, opcional, padrão 32) — O número de quadros em cada vídeo.
tubelet_size (list[int], opcional, padrão [2, 16, 16]) — O tamanho (resolução) de cada tubelet.
num_channels (int, opcional, padrão 3) — O número de canais de entrada.
hidden_size (int, opcional, padrão 768) — Dimensão das representações ocultas.
num_hidden_layers (int, opcional, padrão 12) — Número de camadas ocultas no decodificador do Transformer.
num_attention_heads (int, opcional, padrão 12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
intermediate_size (int, opcional, padrão 3072) — Dimensão das representações do MLP.
hidden_act (str, opcional, padrão gelu_fast) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
hidden_dropout_prob (Union[float, int], opcional, padrão 0.0) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.
attention_probs_dropout_prob (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
layer_norm_eps (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização de camada.
qkv_bias (bool, opcional, padrão True) — Se deve adicionar um viés às queries, keys e values.
pooler_output_size (int, opcional) — Dimensão da camada pooler. Se for None, o valor padrão é hidden_size.
pooler_act (str, opcional, padrão "tanh") — A função de ativação a ser usada pelo pooler.

Esta é a classe de configuração para armazenar a configuração de um VivitModel. Ela é usada para instanciar um modelo Vivit de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do google/vivit-b-16x2-kinetics400

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe transformers.VivitImageProcessor

< source >

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

Parâmetros

do_resize (bool, opcional, padrão True) — Se as dimensões (altura, largura) da imagem devem ser redimensionadas para o size especificado. Pode ser sobrescrito pelo parâmetro do_resize no método preprocess.
size (dict[str, int] opcional, padrão {"shortest_edge" -- 256}): Tamanho da imagem de saída após o redimensionamento. A aresta mais curta da imagem será redimensionada para size["shortest_edge"] mantendo a proporção da imagem original. Pode ser substituído por size no método preprocess.
resample (PILImageResampling, opcional, padrão Resampling.BILINEAR) — Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser sobrescrito pelo parâmetro resample no método preprocess.
do_center_crop (bool, opcional, padrão True) — Se deve recortar a imagem centralmente para o crop_size especificado. Pode ser sobrescrito pelo parâmetro do_center_crop no método preprocess.
crop_size (dict[str, int], opcional, padrão {"height" -- 224, "width": 224}): Tamanho da imagem após aplicar o recorte central. Pode ser sobrescrito pelo parâmetro crop_size no método preprocess.
do_rescale (bool, opcional, padrão True) — Se a imagem deve ser redimensionada pelo fator de escala especificado rescale_factor. Pode ser sobrescrito pelo parâmetro do_rescale no método preprocess.
rescale_factor (int ou float, opcional, padrão 1/127.5) — Define o fator de escala a ser usado ao reescalar a imagem. Pode ser substituído pelo parâmetro rescale_factor no método preprocess.
offset (bool, opcional, padrão True) — Se a imagem deve ser escalada nas direções negativa e positiva. Pode ser sobrescrito pelo offset no método preprocess.
do_normalize (bool, opcional, padrão True) — Indica se a imagem deve ser normalizada. Pode ser sobrescrito pelo parâmetro do_normalize no método preprocess.
image_mean (float ou list[float], opcional, padrão IMAGENET_STANDARD_MEAN) — Média a ser usada ao normalizar a imagem. Este é um float ou uma lista de floats com o comprimento igual ao número de canais da imagem. Pode ser sobrescrito pelo parâmetro image_mean no método preprocess.
image_std (float ou list[float], opcional, padrão IMAGENET_STANDARD_STD) — Desvio padrão a ser utilizado na normalização da imagem. Este é um float ou uma lista de floats com o comprimento correspondente ao número de canais da imagem. Pode ser sobrescrito pelo parâmetro image_std no método preprocess.

Constrói um processador de imagem Vivit.

pré-processamento

< source >

Parâmetros

videos (ImageInput) — Quadros de vídeo para pré-processar. Espera um único lote ou um lote de quadros de vídeo com valores de pixel variando de 0 a 255. Se estiver passando quadros com valores de pixel entre 0 e 1, defina do_rescale=False.
do_resize (bool, opcional, padrão self.do_resize) — Se deve redimensionar a imagem.
size (dict[str, int], opcional, padrão self.size) — Tamanho da imagem após aplicar o redimensionamento.
resample (PILImageResampling, opcional, padrão self.resample) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores do enum PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_center_crop (bool, opcional, padrão self.do_centre_crop) — Se deve aplicar recorte centralizado na imagem.
crop_size (dict[str, int], opcional, padrão self.crop_size) — Tamanho da imagem após aplicar o recorte central.
do_rescale (bool, opcional, padrão self.do_rescale) — Se deve reescalar os valores da imagem para [-1 - 1] se offset for True, ou para [0, 1] caso contrário.
rescale_factor (float, opcional, padrão self.rescale_factor) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
offset (bool, opcional, padrão self.offset) — Se a imagem deve ser escalada nas direções negativa e positiva.
do_normalize (bool, opcional, padrão self.do_normalize) — Se a imagem deve ser normalizada.
image_mean (float ou list[float], opcional, padrão self.image_mean) — Média da imagem.
image_std (float ou list[float], opcional, padrão self.image_std) — Desvio padrão da imagem.
return_tensors (str ou TensorType, opcional) — O tipo de tensores a serem retornados. Pode ser um dos seguintes:
- Unset: Retorna uma lista de np.ndarray.
- TensorType.PYTORCH ou 'pt': Retorna um lote do tipo torch.Tensor.
- TensorType.NUMPY ou 'np': Retorna um lote do tipo np.ndarray.
data_format (ChannelDimension ou str, opcional, padrão é ChannelDimension.FIRST) — O formato da dimensão de canal para a imagem de saída. Pode ser um dos seguintes:
- ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- ChannelDimension.LAST: imagem no formato (altura, largura, número de canais).
- Unset: Use o formato de dimensão de canal inferido da imagem de entrada.
input_data_format (ChannelDimension ou str, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
- "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).

Pré-processa uma imagem ou um lote de imagens.

VivitVideoProcessor

classe transformers.VivitVideoProcessor

< source >

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

Parâmetros

do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'shortest_edge' -- 256}): Descreve as dimensões máximas de entrada para o modelo.
default_to_square (bool, kwargs, opcional, padrão False) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 2) — Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
rescale_factor (float, kwargs, opcional, padrão 0.00784313725490196) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
do_center_crop (bool, kwargs, opcional, padrão True) — Se deve recortar a imagem pelo centro.
do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 224, 'width': 224}): Tamanho da imagem de saída após aplicar center_crop.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
- "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
do_sample_frames (bool, kwargs, opcional, padrão False) — Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro.
video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadados do vídeo contendo informações sobre a duração total, fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento
fps (Annotated[int | float | None, None], kwargs) — Quantidade de quadros-alvo a amostrar por segundo quando do_sample_frames=True.
num_frames (Annotated[int | None, None], kwargs) — Número máximo de quadros a amostrar quando do_sample_frames=True.
return_metadata (bool, kwargs, opcional, padrão False) — Se deve retornar ou não os metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
- 'pt': Retorna objetos torch.Tensor do PyTorch.
- 'np': Retorna objetos np.ndarray do NumPy.
**kwargs (VideosKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Constrói um processador de vídeo VivitVideoProcessor.

pré-processamento

< source >

( videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]]]**kwargs: *<class 'transformers.processing_utils.VideosKwargs'> ) → ~image_processing_base.BatchFeature

Parâmetros

videos (Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]) — Vídeo a ser pré-processado. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se passar vídeos com valores de pixel entre 0 e 1, defina do_rescale=False.
do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB.
do_resize (bool, kwargs, opcional) — Se deve redimensionar a imagem.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
default_to_square (bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
do_normalize (bool, kwargs, opcional) — Se a imagem deve ser normalizada.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
- "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
do_sample_frames (bool, kwargs, opcional) — Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro.
video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Metadados do vídeo contendo informações sobre a duração total, fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento
fps (Annotated[int | float | None, None], kwargs) — Quantidade de quadros-alvo a amostrar por segundo quando do_sample_frames=True.
num_frames (Annotated[int | None, None], kwargs) — Número máximo de quadros a amostrar quando do_sample_frames=True.
return_metadata (bool, kwargs, opcional) — Se deve retornar ou não os metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.

Retorna

~image_processing_base.BatchFeature

data (dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.).
tensor_type (Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

VivitModel

classe transformers.VivitModel

< source >

( config: VivitConfigadd_pooling_layer: bool = True )

Parâmetros

config (VivitConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
add_pooling_layer (bool, opcional, padrão True) — Se deve adicionar uma camada de pooling

O modelo Vivit puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< source >

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

Parâmetros

pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando VivitImageProcessor. Consulte VivitImageProcessor.call() para obter detalhes (processor_class usa VivitImageProcessor para processar imagens).
interpolate_pos_encoding (bool, opcional, padrão False) — Se deve interpolar as codificações de posição pré-treinadas.
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?

Retorna

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Um BaseModelOutputWithPooling ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (VivitConfig) e das entradas.

O método forward do VivitModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.
pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

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

classe transformers.VivitForVideoClassification

< source >

( config: VivitConfig )

Parâmetros

config (VivitConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo ViViT Transformer com uma cabeça de classificação de vídeo no topo (uma camada linear no topo do estado oculto final do token [CLS]), por exemplo, para o Kinetics-400.

Observe que é possível fazer o fine-tuning do ViT em imagens de resolução maior do que aquelas em que ele foi treinado, definindo interpolate_pos_encoding como True no forward do modelo. Isso interpola os embeddings de posição pré-treinados para a resolução mais alta.

forward

< source >

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

Parâmetros

pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando VivitImageProcessor. Consulte VivitImageProcessor.call() para obter detalhes (processor_class usa VivitImageProcessor para processar imagens).
labels (torch.LongTensor de forma (batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de imagem. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio); se config.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
interpolate_pos_encoding (bool, opcional, padrão False) — Se deve interpolar as codificações de posição pré-treinadas.

Retorna

ImageClassifierOutput ou tuple(torch.Tensor)

Um ImageClassifierOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (VivitConfig) e das entradas.

O método forward de VivitForVideoClassification sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação (ou regressão se config.num_labels==1).
logits (torch.Tensor de forma (batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, patch_size, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

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

>>> from transformers import VivitImageProcessor, VivitForVideoClassification
>>> from huggingface_hub import hf_hub_download

>>> np.random.seed(0)


>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`list[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])


>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`list[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices


>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample 32 frames
>>> indices = sample_frame_indices(clip_len=32, frame_sample_rate=4, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container=container, indices=indices)

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

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

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

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

Update on GitHub