Transformers documentation
LLaVa-NeXT-Video
Este modelo foi publicado no HF papers em 31/05/2024 e contribuído para o Hugging Face Transformers em 26/06/2024.
LLaVa-NeXT-Video
Visão geral
O modelo LLaVa-NeXT-Video foi proposto em LLaVA-NeXT: A Strong Zero-shot Video Understanding Model por Yuanhan Zhang, Bo Li, Haotian Liu, Yong Jae Lee, Liangke Gui, Di Fu, Jiashi Feng, Ziwei Liu, Chunyuan Li. O LLaVa-NeXT-Video aprimora o LLaVa-NeXT por meio de fine-tuning em uma mistura de conjuntos de dados de vídeo e imagem, aumentando assim o desempenho do modelo em vídeos.
LLaVA-NeXT apresenta, surpreendentemente, um forte desempenho na compreensão de conteúdo de vídeo de forma zero-shot, graças à técnica AnyRes que utiliza. A técnica AnyRes representa naturalmente uma imagem de alta resolução em múltiplas imagens. Essa técnica é naturalmente generalizável para representar vídeos, pois vídeos podem ser considerados como um conjunto de quadros (semelhante a um conjunto de imagens no LLaVA-NeXT). A versão atual do LLaVA-NeXT faz uso do AnyRes e é treinada com fine-tuning supervisionado (SFT) sobre o LLaVA-Next em dados de vídeo para alcançar melhores capacidades de compreensão de vídeo. O modelo é o SOTA atual entre os modelos de código aberto no VideoMME bench.
A introdução do blog é a seguinte:
Em 30 de janeiro de 2024, lançamos o LLaVA-NeXT, um Large Multimodal Model (LMM) de código aberto treinado exclusivamente em dados de texto e imagem. Com a técnica AnyRes proposta, ele aprimora as capacidades de raciocínio, OCR e conhecimento do mundo, demonstrando desempenho notável em uma ampla gama de tarefas de compreensão multimodal baseadas em imagem, e até mesmo superando o Gemini-Pro em vários benchmarks de imagem, como MMMU e MathVista.
**Na exploração de hoje, mergulhamos no desempenho do LLaVA-NeXT no âmbito de tarefas de compreensão de vídeo. Revelamos que o LLaVA-NeXT apresenta, surpreendentemente, um forte desempenho na compreensão de conteúdo de vídeo. A versão atual do LLaVA-NeXT para vídeos traz várias melhorias:**
- Capacidades de representação de vídeo em zero-shot com AnyRes: a técnica AnyRes representa naturalmente uma imagem de alta resolução em múltiplas imagens que um VIT pré-treinado é capaz de processar, formando-as em uma sequência concatenada. Essa técnica é naturalmente generalizável para representar vídeos (compostos por múltiplos quadros), permitindo que o modelo LLaVA-Next, treinado apenas com imagens, execute-se de forma surpreendentemente bem em tarefas de vídeo. Notavelmente, esta é a primeira vez que LMMs demonstram uma forte capacidade de transferência de modalidade em zero-shot.
- A inferência com generalização de comprimento melhora em vídeos mais longos. A técnica de escalonamento linear permite a generalização de comprimento, permitindo que o LLaVA-NeXT processe eficazmente vídeos longos, superando a limitação do “max_token_length” do LLM.
- Capacidade robusta de compreensão de vídeo. (1) O LLaVA-Next-Image, que combina as duas técnicas acima, apresenta desempenho zero-shot superior ao de LMMs de código aberto ajustados em vídeos. (2) O LLaVA-Next-Video, que realiza um ajuste fino supervisionado (SFT) do LLaVA-Next-Image em dados de vídeo, atinge melhores capacidades de compreensão de vídeo em comparação com o LLaVA-Next-Image. (3) O LLaVA-Next-Video-DPO, que alinha a resposta do modelo com o feedback de IA usando otimização de preferência direta (DPO), demonstra um aumento significativo no desempenho.
- Implantação e inferência eficientes com SGLang. Ele permite inferência 5x mais rápida em tarefas de vídeo, viabilizando um serviço mais escalável, como a re-legendagem de vídeos em escala de milhões. Consulte as instruções em nosso repositório.**
Este modelo foi contribuído por RaushanTurganbay. O código original pode ser encontrado aqui.
Dicas de uso
- Recomendamos que os usuários utilizem
padding_side="left"ao realizar a geração em lote, pois isso resulta em resultados mais precisos. Basta garantir que você chameprocessor.tokenizer.padding_side = "left"antes de gerar.
- Llava-Next usa um número diferente de patches para as imagens e, portanto, precisa fazer o padding das entradas dentro do código de modelagem, além do padding realizado durante o processamento das entradas. A configuração padrão é “left-padding” se o modelo estiver no modo
eval(), caso contrário, “right-padding”.
Modelos LLaVA após a liberação v4.46 exibirão avisos sobre a adição de
processor.patch_size = {{patch_size}},processor.num_additional_image_tokens = {{num_additional_image_tokens}}eprocessor.vision_feature_select_strategy = {{vision_feature_select_strategy}}. É fortemente recomendável adicionar os atributos ao processor se você for o proprietário do checkpoint do modelo, ou abrir um PR caso não seja. A adição desses atributos faz com que o LLaVA tente inferir o número de tokens de imagem necessários por imagem e expandir o texto com tantos placeholders<image>quanto houver tokens. Geralmente, são cerca de 500 tokens por imagem, portanto, certifique-se de que o texto não seja truncado, pois caso contrário ocorrerá falha ao mesclar os embeddings. Os atributos podem ser obtidos a partir da configuração do modelo, comomodel.config.vision_config.patch_sizeoumodel.config.vision_feature_select_strategy. Onum_additional_image_tokensdeve ser1se o backbone de visão adicionar um token CLS ou0se nada extra for adicionado aos patches de visão.
Formatando prompts com modelos de chat
Cada checkpoint é treinado com um formato de prompt específico, dependendo do backbone do grande modelo de linguagem subjacente. Para garantir o formato correto, use o método apply_chat_template do processador.
Importante:
- Você deve construir um histórico de conversa — passar uma string simples não funcionará.
- Cada mensagem deve ser um dicionário com as chaves
"role"e"content". - O
"content"deve ser uma lista de dicionários para diferentes modalidades, como"text"e"image".
Aqui está um exemplo de como estruturar sua entrada. Usaremos LLaVA-NeXT-Video-7B-hf e um histórico de conversa com vídeos e imagens.
from transformers import LlavaNextVideoProcessor
processor = LlavaNextVideoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
conversation = [
{
"role": "system",
"content": [
{"type": "text", "text": "A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the human's questions."},
],
},
{
"role": "user",
"content": [
{"type": "text", "text": "What’s shown in this image?"},
{"type": "image"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This image shows a red stop sign."},]
},
{
"role": "user",
"content": [
{"type": "text", "text": "Why is this video funny?"},
{"type": "video"},
],
},
]
text_prompt = processor.apply_chat_template(conversation, add_generation_prompt=True)
# Note that the template simply formats your prompt, you still have to tokenize it and obtain pixel values for your visuals
print(text_prompt)🚀 Bônus: Se você estiver usando transformers>=4.49.0, também pode obter uma saída vetorizada de apply_chat_template. Consulte os Exemplos de uso abaixo para mais detalhes sobre como usá-lo.
Exemplo de uso
Modo de Mídia Única
O modelo pode aceitar tanto imagens quanto vídeos como entrada. Aqui está um exemplo de código para inferência em meia precisão (torch.float16):
from huggingface_hub import hf_hub_download
from transformers import LlavaNextVideoForConditionalGeneration, LlavaNextVideoProcessor
# Load the model in half-precision
model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", device_map="auto")
processor = LlavaNextVideoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
# Load the video as an np.array, sampling uniformly 8 frames (can sample more for longer videos)
video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")
conversation = [
{
"role": "user",
"content": [
{"type": "text", "text": "Why is this video funny?"},
{"type": "video", "path": video_path},
],
},
]
inputs = processor.apply_chat_template(conversation, num_frames=8, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=60)
processor.batch_decode(out, skip_special_tokens=True, clean_up_tokenization_spaces=True)Modo de Mídia Mista
O modelo também pode gerar a partir de entradas de imagem e vídeo intercaladas. No entanto, observe que ele não foi treinado em um cenário de imagem e vídeo intercalados, o que pode afetar o desempenho. Abaixo, há um exemplo de uso para entrada de mídia mista; adicione as seguintes linhas ao trecho de código acima:
# Generate from image and video mixed inputs
conversation = [
{
"role": "user",
"content": [
{"type": "text", "text": "How many cats are there in the image?"},
{"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "There are two cats"}],
},
{
"role": "user",
"content": [
{"type": "text", "text": "Why is this video funny?"},
{"type": "video", "path": video_path},
],
},
]
inputs = processor.apply_chat_template(conversation, num_frames=8, add_generation_prompt=True, tokenize=True, return_dict=True, padding=True, return_tensors="pt").to(model.device)
# Generate
generate_ids = model.generate(**inputs, max_length=50)
processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)
Otimização de modelos
Quantização usando Bitsandbytes para eficiência de memória
O modelo pode ser carregado em bits menores, reduzindo significativamente a carga de memória e mantendo o desempenho do modelo original. Isso permite uma implantação eficiente em cenários com recursos limitados.
Primeiro, certifique-se de instalar o bitsandbytes executando pip install bitsandbytes e de ter acesso a uma GPU/acelerador compatível com a biblioteca.
bitsandbytes está sendo refatorado para suportar múltiplos backends além do CUDA. Atualmente, as implementações para ROCm (GPU AMD) e CPU Intel estão maduras, com o Intel XPU em andamento e o suporte a Apple Silicon esperado para o Q4/Q1. Para instruções de instalação e as atualizações mais recentes dos backends, visite este link.
Valorizamos seu feedback para ajudar a identificar bugs antes do lançamento completo! Consulte esses documentos para mais detalhes e links de feedback.
Em seguida, basta carregar o modelo quantizado adicionando BitsAndBytesConfig, conforme mostrado abaixo:
from transformers import LlavaNextVideoForConditionalGeneration
# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
)
model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", quantization_config=quantization_config, device_map="auto")Flash-Attention 2 para acelerar a geração
Além disso, podemos acelerar significativamente a inferência do modelo usando Flash Attention, que é uma implementação mais rápida do mecanismo de atenção usado dentro do modelo.
Primeiro, certifique-se de instalar a versão mais recente do Flash Attention 2:
pip install -U flash-attn --no-build-isolation
Além disso, você deve ter um hardware compatível com Flash-Attention 2. Leia mais sobre isso na documentação oficial do repositório flash attention. O FlashAttention-2 só pode ser usado quando um modelo é carregado em torch.float16 ou torch.bfloat16.
Para carregar e executar um modelo usando Flash Attention-2, basta adicionar attn_implementation="flash_attention_2" ao carregar o modelo, conforme mostrado a seguir:
from transformers import LlavaNextVideoForConditionalGeneration
model = LlavaNextVideoForConditionalGeneration.from_pretrained(
"llava-hf/LLaVA-NeXT-Video-7B-hf", ,
attn_implementation="flash_attention_2",
).to(0, device_map="auto")LlavaNextVideoConfig
classe transformers.LlavaNextVideoConfig
< 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 = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_index: int = 32001video_token_index: int = 32000projector_hidden_act: str = 'gelu'vision_feature_select_strategy: typing.Literal['default', 'full'] = 'default'vision_feature_layer: int | list[int] = -2multimodal_projector_bias: bool = Truetie_word_embeddings: bool = Falseimage_grid_pinpoints: list | None = Nonespatial_pool_mode: str = 'average'spatial_pool_stride: int = 2image_seq_length: int = 576video_seq_length: int = 288 )
Parâmetros
- vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de visão. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto. - image_token_index (
int, opcional, padrão32001) — O índice do token de imagem usado como marcador para as imagens de entrada. - video_token_index (
int, opcional, padrão32000) — O índice do token de vídeo usado como marcador de posição para vídeos de entrada. - projector_hidden_act (
str, opcional, padrãogelu) — A função de ativação usada pelo projetor multimodal. - vision_feature_select_strategy (
Literal[default, full], opcional, padrãodefault) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. - vision_feature_layer (
Union[int, list[int]], opcional, padrão-2) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - multimodal_projector_bias (
bool, opcional, padrãoTrue) — Se deve usar viés no projetor multimodal. - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - image_grid_pinpoints (
List, opcional, padrão[[336, 672], [672, 336], [672, 672], [1008, 336], [336, 1008]]) — Uma lista de resoluções possíveis para processar imagens de alta resolução. Cada item da lista deve ser uma tupla ou lista na forma(height, width). - spatial_pool_mode (
str, opcional, padrão"average") — Modo de pooling a ser usado para vídeos. Pode ser “average”, “max” ou “conv”. - spatial_pool_stride (
int, opcional, padrão 2) — Passo usado na camada de pooling para vídeos. - image_seq_length (
int, opcional, padrão576) — Comprimento da sequência de um embedding de imagem. - video_seq_length (
int, opcional, padrão288) — Comprimento da sequência de um embedding de vídeo.
Esta é a classe de configuração para armazenar a configuração de um LlavaNextVideoModel. Ela é usada para instanciar um modelo Llava Next Video 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 llava-hf/LLaVA-NeXT-Video-7B-hf
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 LlavaNextVideoForConditionalGeneration, LlavaNextVideoConfig, CLIPVisionConfig, LlamaConfig
>>> # Initializing a CLIP-vision config
>>> vision_config = CLIPVisionConfig()
>>> # Initializing a Llama config
>>> text_config = LlamaConfig()
>>> configuration = LlavaNextVideoConfig(vision_config, text_config)
>>> model = LlavaNextVideoForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLlavaNextVideoProcessor
classe transformers.LlavaNextVideoProcessor
< source >( video_processor = Noneimage_processor = Nonetokenizer = Nonechat_template = Nonepatch_size = Nonevision_feature_select_strategy = Nonevideo_token = '<video>'image_token = '<image>'num_additional_image_tokens = 0**kwargs )
Parâmetros
- video_processor (
LlavaNextVideoVideoProcessor) — O processador de vídeo é uma entrada obrigatória. - image_processor (
LlavaNextImageProcessor) — O processador de imagem é uma entrada obrigatória. - tokenizer (
tokenizer_class) — O tokenizer é uma entrada obrigatória. - chat_template (
str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. - patch_size (
int, opcional) — Tamanho do patch da torre de visão. - vision_feature_select_strategy (
str, opcional) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Deve ser a mesma da configuração do modelo - video_token (
str, opcional, padrão"<video>") — Token especial usado para indicar a localização do vídeo. - image_token (
str, opcional, padrão"<image>") — Token especial usado para indicar a localização da imagem. - num_additional_image_tokens (
int, opcional, padrão 0) — Número de tokens adicionais adicionados aos embeddings da imagem, como CLS (+1). Se o backbone não tiver CLS ou outros tokens extras anexados, não é necessário definir este argumento.
Constrói um LlavaNextVideoProcessor que encapsula um processador de vídeo, um processador de imagem e um tokenizer em um único processador.
LlavaNextVideoProcessor oferece todas as funcionalidades de LlavaNextVideoVideoProcessor, LlavaNextImageProcessor e tokenizer_class. Consulte ~LlavaNextVideoVideoProcessor, ~LlavaNextImageProcessor e ~tokenizer_class para mais informações.
LlavaNextVideoVideoProcessor
classe transformers.LlavaNextVideoVideoProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.VideosKwargs'> )
Parâmetros
- do_convert_rgb (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser convertida para RGB. - do_resize (
bool, kwargs, opcional, padrãoTrue) — Se deve redimensionar a imagem. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão{'shortest_edge' -- 224}): Descreve as dimensões máximas de entrada para o modelo. - default_to_square (
bool, kwargs, opcional, padrãoFalse) — 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ão3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeraçãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional, padrãoTrue) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional, padrão0.00392156862745098) — Fator de reescala para reescalar a imagem, casodo_rescaleesteja definido comoTrue. - do_normalize (
bool, kwargs, opcional, padrãoTrue) — Se a imagem deve ser normalizada. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.48145466, 0.4578275, 0.40821073]) — Média da imagem a ser usada para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão[0.26862954, 0.26130258, 0.27577711]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - do_center_crop (
bool, kwargs, opcional, padrãoTrue) — 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 aplicarcenter_crop. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.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"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.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ãoFalse) — 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 quandodo_sample_frames=True. - num_frames (
Annotated[int | None, None], kwargs) — Número máximo de quadros a amostrar quandodo_sample_frames=True. - return_metadata (
bool, kwargs, opcional, padrãoFalse) — 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 objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo 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 LlavaNextVideoVideoProcessor.
LlavaNextVideoModel
classe transformers.LlavaNextVideoModel
< source >( config: LlavaNextVideoConfig )
Parâmetros
- config (LlavaNextVideoConfig) — 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.
O modelo Llava-Next, que consiste em um backbone de visão e um modelo de linguagem sem a cabeça de modelagem de linguagem.
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 >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_sizes: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.modeling_flash_attention_utils.FlashAttentionKwargs'> ) → LlavaNextVideoModelOutputWithPast or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- pixel_values (
torch.Tensorde 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 LlavaNextImageProcessor. Consulte LlavaNextImageProcessor.call() para mais detalhes (LlavaNextVideoProcessor usa LlavaNextImageProcessor para processar imagens). - pixel_values_videos (
torch.Tensorde forma(batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando LlavaNextVideoVideoProcessor. Consulte LlavaNextVideoVideoProcessor.call() para mais detalhes (LlavaNextVideoProcessor usa LlavaNextVideoVideoProcessor para processar vídeos). - image_sizes (
torch.LongTensorde forma(batch_size, 2), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_select_strategy (
str, opcional, padrão"default") — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser"default"ou"full". Se"default", o token CLS é removido dos recursos visuais. Se"full", os recursos visuais completos são usados. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.
Retorna
LlavaNextVideoModelOutputWithPast ou tuple(torch.Tensor)
Uma LlavaNextVideoModelOutputWithPast 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 (LlavaNextVideoConfig) e das entradas.
O método forward do LlavaNextVideoModel 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
Moduleem 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.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.Se
past_key_valuesfor usado, apenas o último hidden-state das sequências, com forma(batch_size, 1, hidden_size), é retornado.past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada
past_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
image_hidden_states (
torch.Tensor, opcional) — Umtorch.Tensorde tamanho(batch_size, num_images, sequence_length, hidden_size). image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.video_hidden_states (
torch.Tensor, opcional) — Umtorch.Tensorde tamanho(batch_size * num_frames, num_videos, sequence_length, hidden_size). video_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.
get_image_features
< source >( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_patches, channels, height, width)) — Os tensores correspondentes às imagens de entrada. - image_sizes (
torch.Tensorde forma(num_images, 2)) — Tamanho real de cada imagem (H, W). - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - image_sizes (
torch.Tensorde forma(batch_size, 2)) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_select_strategy (
str, opcional) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser"default"ou"full"
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 (LlavaNextVideoConfig) e das entradas.
Obtém os estados ocultos finais da imagem da torre de visão e aplica a projeção multimodal.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
get_placeholder_mask
< source >( input_ids: LongTensorinputs_embeds: Tensorimage_features: typing.Optional[torch.Tensor] = Nonevideo_features: typing.Optional[torch.Tensor] = None )
Obtém a máscara de placeholder multimodal a partir de input_ids ou inputs_embeds e verifica se a contagem de tokens de placeholder é igual ao comprimento dos recursos multimodais. Se os comprimentos forem diferentes, um erro é lançado.
get_video_features
< source >( pixel_values_videos: Tensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values_videos (
torch.Tensor]de forma(batch_size, num_frames, channels, height, width)) — Os tensores correspondentes ao vídeo de entrada. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_select_strategy (
str, opcional) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser"default"ou"full"
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 (LlavaNextVideoConfig) e das entradas.
Obtém os estados ocultos finais do vídeo da torre de visão e aplica a projeção multimodal.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
pack_image_features
< source >( image_featuresimage_sizesvision_feature_select_strategyimage_newline = None )
Parâmetros
- image_features (
list[torch.Tensor]de comprimento num_images, cada um com forma(num_patches, image_length, embed_dim)) — Lista de tensores de características de imagem, em que cada um contém todas as características visuais de todos os patches. - image_sizes (
torch.Tensorde forma(num_images, 2)) — Tamanho real de cada imagem (H, W). - vision_feature_select_strategy (
str) — Estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. - image_newline (
torch.Tensorde forma(embed_dim)) — Vetor de incorporação de nova linha.
Redimensione, remova o padding e, em seguida, empacote cada image_feature em um único tensor image_features contendo todos os vetores visuais.
LlavaNextVideoForConditionalGeneration
classe transformers.LlavaNextVideoForConditionalGeneration
< source >( config: LlavaNextVideoConfig )
Parâmetros
- config (LlavaNextVideoConfig) — 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.
O modelo LLAVA-NeXT, que consiste em um backbone de visão e um modelo de linguagem.
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 >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Noneimage_sizes: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LlavaNextVideoCausalLMOutputWithPast or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- pixel_values (
torch.Tensorde 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 LlavaNextImageProcessor. Consulte LlavaNextImageProcessor.call() para mais detalhes (LlavaNextVideoProcessor usa LlavaNextImageProcessor para processar imagens). - pixel_values_videos (
torch.Tensorde forma(batch_size, num_frames, num_channels, frame_size, frame_size), opcional) — Os tensors correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando LlavaNextVideoVideoProcessor. Consulte LlavaNextVideoVideoProcessor.call() para mais detalhes (LlavaNextVideoProcessor usa LlavaNextVideoVideoProcessor para processar vídeos). - image_sizes (
torch.LongTensorde forma(batch_size, 2), opcional) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nopast_key_valuesretornado pelo modelo em uma etapa anterior da decodificação, quandouse_cache=Trueouconfig.use_cache=True.Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum
past_key_valuesfor passado, DynamicCache será inicializado por padrão.O modelo sairá no mesmo formato de cache que é fornecido como entrada.
Se
past_key_valuesforem usados, espera-se que o usuário insira apenas osinput_idsnão processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma(batch_size, unprocessed_length), em vez de todos osinput_idscom a forma(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_select_strategy (
str, opcional) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser"default"ou"full". - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., config.vocab_size]ou ser -100 (veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size]. - use_cache (
bool, opcional) — Se definido comoTrue, os estados de chave-valorpast_key_valuessão retornados e podem ser usados para acelerar a decodificação (vejapast_key_values). - logits_to_keep (
Union[int, torch.Tensor], opcional, padrão0) — Se for umint, calcula os logits para os últimoslogits_to_keeptokens. Se for0, calcula os logits para todos osinput_ids(caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for umtorch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional:last_hidden_states, opcional:hidden_states, opcional:attentions)pooler_outputde forma(batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.
Retorna
LlavaNextVideoCausalLMOutputWithPast ou tuple(torch.Tensor)
Um LlavaNextVideoCausalLMOutputWithPast 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 (LlavaNextVideoConfig) e das entradas.
O método forward de LlavaNextVideoForConditionalGeneration 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).past_key_values (
Cache, opcional, retornado quandouse_cache=Trueé passado ou quandoconfig.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada
past_key_values) para acelerar a decodificação sequencial.hidden_states (
tuple[torch.Tensor], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
image_hidden_states (
torch.Tensor, opcional) — Umtorch.Tensorde tamanho (batch_size * num_patches, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.video_hidden_states (
torch.Tensor, opcional) — Umtorch.Tensorde tamanho(batch_size * num_frames, num_videos, sequence_length, hidden_size). video_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.
Exemplo:
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import av
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration
>>> 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])
>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf", device_map="auto")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> prompt = "USER: <video>\nWhy is this video funny? ASSISTANT:"
>>> video_path = hf_hub_download(repo_id="raushan-testing-hf/videos-test", filename="sample_demo_1.mp4", repo_type="dataset")
>>> container = av.open(video_path)
>>> # sample uniformly 8 frames from the video (model was trained with 32 frames per video, but this video is short)
>>> total_frames = container.streams.video[0].frames
>>> indices = np.arange(0, total_frames, total_frames / 8).astype(int)
>>> clip = read_video_pyav(container, indices)
>>> inputs_video = processor(text=prompt, videos=clip, return_tensors="pt").to(model.device)
>>> # load an image to generate from an image
>>> prompt = "USER:<image>\nWhat is shown in this image? ASSISTANT:"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs_image = processor(text=prompt, images=image, return_tensors="pt").to(model.device)
>>> # Generate from video
>>> generate_ids = model.generate(**inputs_video, max_length=50)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER:\nWhy is this video funny? ASSISTANT: The humor in this video comes from the unexpected and endearing sight of a baby wearing glasses and (...)"
>>> # Generate from image
>>> generate_ids = model.generate(**inputs_image, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER: \nWhat's the content of the image? ASSISTANT: The image shows a red stop sign on a pole, with a traditional Chinese archway (...)"get_image_features
< source >( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_patches, channels, height, width)) — Os tensores correspondentes às imagens de entrada. - image_sizes (
torch.Tensorde forma(num_images, 2)) — Tamanho real de cada imagem (H, W). - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - image_sizes (
torch.Tensorde forma(batch_size, 2)) — Os tamanhos das imagens no lote, sendo (altura, largura) para cada imagem. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_select_strategy (
str, opcional) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser"default"ou"full"
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 (LlavaNextVideoConfig) e das entradas.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration
>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]get_video_features
< source >( pixel_values_videos: Tensorvision_feature_layer: int | list[int] | None = Nonevision_feature_select_strategy: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- pixel_values_videos (
torch.Tensor]de forma(batch_size, num_frames, channels, height, width)) — Os tensores correspondentes ao vídeo de entrada. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_layer (
Union[int, list[int]], opcional) — O índice da camada para selecionar o recurso visual. Se vários índices forem fornecidos, os recursos visuais dos índices correspondentes serão concatenados para formar os recursos visuais. - vision_feature_select_strategy (
str, opcional) — A estratégia de seleção de recursos usada para selecionar o recurso visual do backbone visual. Pode ser"default"ou"full"
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 (LlavaNextVideoConfig) e das entradas.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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.
Exemplo:
>>> from PIL import Image
>>> from transformers import AutoProcessor, LlavaNextVideoForConditionalGeneration
>>> model = LlavaNextVideoForConditionalGeneration.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/LLaVA-NeXT-Video-7B-hf")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]