# Video-LLaVA ## Visão geral Video-LLaVa é um LLM multimodal de código aberto treinado por meio do ajuste fino de LlamA/Vicuna em dados de instrução multimodal gerados por Llava1.5 e VideChat. Trata-se de um modelo de linguagem autoregressivo, baseado na arquitetura transformer. O Video-LLaVa unifica as representações visuais ao espaço de características da linguagem, permitindo que um LLM execute capacidades de raciocínio visual simultaneamente em imagens e vídeos. O modelo Video-LLaVA foi proposto em [Video-LLaVA: Learning United Visual Representation by Alignment Before Projection](https://huggingface.co/papers/2311.10122) por Bin Lin, Yang Ye, Bin Zhu, Jiaxi Cui, Munang Ning, Peng Jin, Li Yuan. O resumo do artigo é o seguinte: *O Large Vision-Language Model (LVLM) aprimorou o desempenho de diversas tarefas downstream na compreensão visual-linguística. A maioria das abordagens existentes codifica imagens e vídeos em espaços de recursos separados, que são então fornecidos como entradas para grandes modelos de linguagem. No entanto, devido à falta de tokenização unificada para imagens e vídeos, ou seja, desalinhamento antes da projeção, torna-se desafiador para um Large Language Model (LLM) aprender interações multimodais a partir de várias camadas de projeção de baixa qualidade. Neste trabalho, unificamos a representação visual no espaço de recursos da linguagem para avançar o LLM fundamental em direção a um LVLM unificado. Como resultado, estabelecemos uma linha de base simples, porém robusta, para LVLM, a Video-LLaVA, que aprende a partir de um conjunto de dados misto de imagens e vídeos, aprimorando-se mutuamente. A Video-LLaVA alcança desempenhos superiores em uma ampla gama de 9 benchmarks de imagem em 5 conjuntos de dados de perguntas e respostas de imagem e 4 toolkits de benchmark de imagem. Além disso, nossa Video-LLaVA também supera a Video-ChatGPT em 5,8%, 9,9%, 18,6% e 10,1% em MSRVTT, MSVD, TGIF e ActivityNet, respectivamente. Notavelmente, extensos experimentos demonstram que a Video-LLaVA beneficia mutuamente imagens e vídeos dentro de uma representação visual unificada, superando modelos projetados especificamente para imagens ou vídeos. Esperamos que este trabalho forneça modestas percepções sobre as entradas multimodais para o LLM* ## Dicas de uso - Recomendamos que os usuários utilizem padding_side="left" ao calcular a geração em lote, pois isso leva a resultados mais precisos. Basta ter certeza de chamar processor.tokenizer.padding_side = "left" antes de gerar. - Observe que o modelo não foi explicitamente treinado para processar múltiplas imagens/vídeos no mesmo prompt, embora isso seja tecnicamente possível, você pode obter resultados imprecisos. - Observe que as entradas de vídeo devem ter exatamente 8 frames na entrada, pois os modelos foram treinados nessa configuração. Este modelo foi contribuído por [RaushanTurganbay](https://huggingface.co/RaushanTurganbay). O código original pode ser encontrado [aqui](https://github.com/PKU-YuanGroup/Video-LLaVA). > [!NOTE] > Os modelos LLaVA após o lançamento da v4.46 exibirão avisos sobre a adição de `processor.patch_size = {{patch_size}}`, `processor.num_additional_image_tokens = {{num_additional_image_tokens}}` e `processor.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. Adicionar esses 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 `` 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 da configuração do modelo, como `model.config.vision_config.patch_size` ou `model.config.vision_feature_select_strategy`. O `num_additional_image_tokens` deve ser `1` se o backbone de visão adicionar um token CLS ou `0` se nada extra for adicionado aos patches de visão. ## 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`): ```python import av import numpy as np from transformers import VideoLlavaForConditionalGeneration, VideoLlavaProcessor 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]) # Load the model in half-precision model = VideoLlavaForConditionalGeneration.from_pretrained("LanguageBind/Video-LLaVA-7B-hf", device_map="auto") processor = VideoLlavaProcessor.from_pretrained("LanguageBind/Video-LLaVA-7B-hf") # Load the video as an np.array, sampling uniformly 8 frames 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) total_frames = container.streams.video[0].frames indices = np.arange(0, total_frames, total_frames / 8).astype(int) video = read_video_pyav(container, indices) # For better results, we recommend to prompt the model in the following format prompt = "USER: