# LFM2-VL

## Visão geral

[LFM2-VL](https://www.liquid.ai/blog/lfm2-vl-efficient-vision-language-models) é a primeira série de modelos fundacionais de visão-linguagem desenvolvida pela [Liquid AI](https://liquid.ai/). Esses modelos multimodais foram projetados para implantação com baixa latência e consciente do dispositivo. O LFM2-VL estende a família LFM2 de Liquid Foundation Models (LFMs) de pesos abertos para o espaço de visão-linguagem, suportando entradas de texto e imagem com resoluções variáveis.

## Arquitetura

LFM2-VL consiste em três componentes principais: um backbone de modelo de linguagem, um codificador de visão e um projetor multimodal. O LFM2-VL é construído sobre o backbone LFM2, herdando de LFM2-1.2B (para LFM2-VL-1.6B) ou LFM2-350M (para LFM2-VL-450M). Para a torre de visão, o LFM2-VL utiliza codificadores SigLIP2 NaFlex para converter imagens de entrada em sequências de tokens. Duas variantes são implementadas:

* Otimizado em forma (400M) para capacidades de visão mais detalhadas no LFM2-VL-1.6B
* Base (86M) para processamento rápido de imagens para LFM2-VL-450M

O codificador processa imagens em sua resolução nativa, de até 512×512 pixels, lidando de forma eficiente com imagens menores sem aumentar o tamanho e suportando proporções não padrão sem distorção. Imagens maiores são divididas em patches quadrados não sobrepostos de 512×512 cada, preservando os detalhes. No LFM2-VL-1.6B, o modelo também recebe uma miniatura (uma versão pequena e reduzida da imagem original que captura a cena geral) para aprimorar a compreensão do contexto global e o alinhamento. Tokens especiais marcam a posição de cada patch e indicam o início da miniatura. O conector multimodal é um conector MLP de 2 camadas com pixel unshuffle para reduzir a contagem de tokens de imagem.

## Exemplo

O exemplo a seguir mostra como gerar uma resposta usando a classe `AutoModelForImageTextToText`.

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

\
# Load model and processor
model_id = "LiquidAI/LFM2-VL-1.6B"
model = AutoModelForImageTextToText.from_pretrained(
    model_id,
    device_map="auto",
    dtype="bfloat16",
)
processor = AutoProcessor.from_pretrained(model_id)

# Load image and create conversation
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://www.ilankelman.org/stopsigns/australia.jpg"},
            {"type": "text", "text": "What is in this image?"},
        ],
    },
]

# Generate answer
inputs = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
    tokenize=True,
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=64)
processor.batch_decode(outputs, skip_special_tokens=True)[0]
```

## Lfm2VlImageProcessor[[transformers.Lfm2VlImageProcessor]]

#### transformers.Lfm2VlImageProcessor[[transformers.Lfm2VlImageProcessor]]

```python
transformers.Lfm2VlImageProcessor(**kwargs: *<class 'transformers.models.lfm2_vl.image_processing_lfm2_vl.Lfm2VlImageProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/image_processing_lfm2_vl.py#L218)

**Parâmetros:**

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem 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 `{'height' : 512, 'width': 512}`): Descreve as dimensões máximas de entrada para o modelo.

default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

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.00392156862745098`) : Fator de redimensionamento para redimensionar 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_pad (`bool`, *kwargs*, padrão `True`) : 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.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

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 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

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.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

downsample_factor (`int`, *kwargs*, *opcional*, padrão `2`) : O fator de redução de amostragem para as imagens usado ao redimensionar a imagem.

do_image_splitting (`bool`, *kwargs*, *opcional*, padrão `True`) : Se as imagens grandes devem ser divididas em uma grade de tiles menores. Quando habilitado, imagens que excedem o limite máximo de tokens são divididas em vários tiles com base nas restrições de `min_tiles` e `max_tiles`.

min_tiles (`int`, *kwargs*, *opcional*, padrão `2`) : Número mínimo de tiles (largura × altura) a serem usados ao dividir uma imagem em uma grade. A configuração da grade é escolhida para manter a proporção original, permanecendo dentro da faixa de `min_tiles` a `max_tiles`.

max_tiles (`int`, *kwargs*, *opcional*, padrão é `10`) : Número máximo de tiles (largura × altura) a serem usados ao dividir uma imagem em uma grade. A configuração da grade é escolhida para manter a proporção original, permanecendo dentro da faixa de `min_tiles` a `max_tiles`.

use_thumbnail (`bool`, *kwargs*, *opcional*, padrão `True`) : Indica se uma versão em miniatura da imagem deve ser incluída ao dividir em tiles. A miniatura fornece uma visão geral de baixa resolução da imagem inteira e é adicionada como um patch adicional quando a grade possui mais de um tile.

min_image_tokens (`int`, *kwargs*, *opcional*, padrão `64`) : Número mínimo de tokens de imagem (patches) a serem gerados para uma imagem. Imagens menores que esse limite serão ampliadas para atender ao requisito mínimo de tokens.

max_image_tokens (`int`, *kwargs*, *opcional*, padrão `256`) : Número máximo de tokens de imagem (patches) permitidos para uma única imagem. Imagens que excederem esse limite serão divididas em múltiplos tiles ou reduzidas de escala conforme necessário.

encoder_patch_size (`int`, *kwargs*, *opcional*, padrão `16`) : O tamanho do patch usado pelo codificador de visão. As imagens são divididas em patches desse tamanho, e tanto a altura quanto a largura devem ser divisíveis por esse valor (após considerar o fator de downsampling).

tile_size (`int`, *kwargs*, *opcional*, padrão `512`) : O tamanho de cada tile ao dividir imagens grandes em uma grade. Cada tile será redimensionado para essa dimensão antes de ser processado em patches.

max_pixels_tolerance (`float`, *kwargs*, *opcional*, padrão `2.0`) : Fator de tolerância para determinar se uma imagem é grande demais. Uma imagem é considerada grande demais se a contagem de pixels exceder `max_image_tokens * encoder_patch_size^2 * downsample_factor^2 * max_pixels_tolerance`.

return_row_col_info (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve retornar informações de linha e coluna para cada imagem no lote. Quando habilitado, a saída inclui os campos `image_rows`, `image_cols` e `image_sizes`, indicando o layout da grade e as dimensões das imagens processadas.

Constrói um processador de imagem Lfm2VlImageProcessor.

#### preprocess[[transformers.Lfm2VlImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382)

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

image_like_kwargs (`dict[str, Any]`, *opcional*) : Sinalizador do desenvolvedor para entradas adicionais semelhantes a imagens que também serão pré-processadas. Use isso apenas se a passagem das entradas como kwarg não funcionar. Por exemplo, `preprocess(images, masks=masks)` é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos, `preprocess(images, image_like_inputs={"masks": masks})` pode ser usado em vez disso.

do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem 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.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`.

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_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.`

do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem.

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 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width).

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

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.

disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

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

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

## Lfm2VlProcessor[[transformers.Lfm2VlProcessor]]

#### transformers.Lfm2VlProcessor[[transformers.Lfm2VlProcessor]]

```python
transformers.Lfm2VlProcessor(image_processor, tokenizer, chat_template: str | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/processing_lfm2_vl.py#L58)

**Parâmetros:**

image_processor (`Lfm2VlImageProcessor`) : O processador de imagens é uma entrada obrigatória.

tokenizer (`tokenizer_class`) : O tokenizer é uma entrada obrigatória.

chat_template (`str`, *opcional*) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.

Constrói um Lfm2VlProcessor que encapsula um processador de imagem e um tokenizer em um único processador.

[Lfm2VlProcessor](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlProcessor) oferece todas as funcionalidades de [Lfm2VlImageProcessor](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlImageProcessor) e `tokenizer_class`. Consulte [~Lfm2VlImageProcessor](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlImageProcessor) e `~tokenizer_class` para mais informações.

#### __call__[[transformers.Lfm2VlProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/processing_lfm2_vl.py#L79)

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *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.

## Lfm2VlConfig[[transformers.Lfm2VlConfig]]

#### transformers.Lfm2VlConfig[[transformers.Lfm2VlConfig]]

```python
transformers.Lfm2VlConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 396, projector_hidden_act: str = 'gelu', projector_hidden_size: int = 2560, projector_bias: bool = True, projector_use_layernorm: bool = True, downsample_factor: int = 2, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/configuration_lfm2_vl.py#L25)

**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_id (`int`, *opcional*, padrão `396`) : O índice do token de imagem usado como marcador para as imagens de entrada.

projector_hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação usada pelo projetor multimodal.

projector_hidden_size (`int`, *opcional*, padrão `2560`) : Dimensionalidade das camadas de projeção de texto e visão.

projector_bias (`bool`, *opcional*, padrão `True`) : Se deve usar viés no projetor multimodal.

projector_use_layernorm (`bool`, *opcional*, padrão `True`) : Se deve usar layernorm no projetor multimodal.

downsample_factor (`int`, *opcional*, padrão 2) : O fator downsample_factor do backbone de visão.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

Esta é a classe de configuração para armazenar a configuração de um Lfm2VlModel. Ela é usada para instanciar um modelo Lfm2 Vl 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 [LiquidAI/LFM2-VL-1.6B](https://huggingface.co/LiquidAI/LFM2-VL-1.6B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Lfm2VlModel[[transformers.Lfm2VlModel]]

#### transformers.Lfm2VlModel[[transformers.Lfm2VlModel]]

```python
transformers.Lfm2VlModel(config: Lfm2VlConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/modeling_lfm2_vl.py#L147)

**Parâmetros:**

config ([Lfm2VlConfig](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Lfm2Vl, que consiste em um backbone de visão e um modelo de linguagem, sem uma cabeça de modelagem de linguagem.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Lfm2VlModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, spatial_shapes: typing.Optional[torch.Tensor] = None, pixel_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/modeling_lfm2_vl.py#L230)

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de 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]`.  [O que são IDs de posição?](../glossary#position-ids)

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 [Lfm2VlImageProcessor](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlImageProcessor). Veja [Lfm2VlImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Lfm2VlProcessor](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlProcessor) usa [Lfm2VlImageProcessor](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlImageProcessor) para processar imagens).

spatial_shapes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*) : As formas espaciais das imagens de entrada.

pixel_attention_mask (`torch.Tensor` de forma `(batch_size, height, width)`, *opcional*) : A máscara de atenção de pixels das imagens de entrada.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_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_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

**Retorna:** `Lfm2VlModelOutputWithPast` ou `tuple(torch.Tensor)`

Uma `Lfm2VlModelOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) compreendendo vários elementos dependendo da configuração ([Lfm2VlConfig](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlConfig)) e das entradas.

O método forward do [Lfm2VlModel](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlModel) 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.

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

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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 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) com a 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 a 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 nas cabeças de autoatenção.
- **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de 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.

#### get_image_features[[transformers.Lfm2VlModel.get_image_features]]

```python
get_image_features(pixel_values: Tensor, spatial_shapes: Tensor, pixel_attention_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/modeling_lfm2_vl.py#L156)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, channels, height, width)`) : Os tensores correspondentes às imagens de entrada.

spatial_shapes (`torch.Tensor` de forma `(batch_size, 2)`) : As formas espaciais das imagens de entrada.

pixel_attention_mask (`torch.Tensor` de forma `(batch_size, height, width)`) : A máscara de atenção de pixels das imagens de entrada.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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 ([Lfm2VlConfig](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlConfig)) 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.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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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) com a 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 a 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 nas cabeças de autoatenção.

## Lfm2VlForConditionalGeneration[[transformers.Lfm2VlForConditionalGeneration]]

#### transformers.Lfm2VlForConditionalGeneration[[transformers.Lfm2VlForConditionalGeneration]]

```python
transformers.Lfm2VlForConditionalGeneration(config: Lfm2VlConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/modeling_lfm2_vl.py#L305)

**Parâmetros:**

config ([Lfm2VlConfig](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo LFM2_VL, que consiste em um backbone de visão e um modelo de linguagem.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais.

#### forward[[transformers.Lfm2VlForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, spatial_shapes: typing.Optional[torch.Tensor] = None, pixel_attention_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/modeling_lfm2_vl.py#L341)

pixel_values (`torch.Tensor` de forma `(batch_size, channels, height, width)`, *opcional*): Os tensores de imagem de entrada. spatial_shapes (`torch.Tensor` de forma `(batch_size, 2)`, *opcional*): As formas espaciais das imagens de entrada. pixel_attention_mask (`torch.Tensor` de forma `(batch_size, height, width)`, *opcional*): A máscara de atenção de pixels das imagens de entrada. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*): Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

Exemplo:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, AutoModelForImageTextToText
>>> from transformers.image_utils import load_image

>>> model = AutoModelForImageTextToText.from_pretrained(
...     "LiquidAI/LFM2-VL-1.6B",
... )
>>> processor = AutoProcessor.from_pretrained(
...     "LiquidAI/LFM2-VL-1.6B",
... )

>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = load_image(url)

>>> conversation = [
...     {
...         "role": "user",
...         "content": [
...             {"type": "image", "image": image},
...             {"type": "text", "text": "What is in this image?"},
...         ],
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     conversation,
...     add_generation_prompt=True,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt"
... )

>>> # Generate
>>> outputs = model.generate(**inputs, max_new_tokens=45)
>>> processor.batch_decode(outputs, skip_special_tokens=True)[0]
'This image depicts a vibrant street scene in what appears to be a Chinatown or similar cultural area. The focal point is a large red stop sign with white lettering, mounted on a pole.'
```

#### get_image_features[[transformers.Lfm2VlForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: Tensor, spatial_shapes: Tensor, pixel_attention_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lfm2_vl/modeling_lfm2_vl.py#L318)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, channels, height, width)`) : Os tensores correspondentes às imagens de entrada.

spatial_shapes (`torch.Tensor` de forma `(batch_size, 2)`) : As formas espaciais das imagens de entrada.

pixel_attention_mask (`torch.Tensor` de forma `(batch_size, height, width)`) : A máscara de atenção de pixels das imagens de entrada.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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 ([Lfm2VlConfig](/docs/transformers/main/pt/model_doc/lfm2_vl#transformers.Lfm2VlConfig)) e das entradas.

- **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 pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por 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) com a 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 a 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, Lfm2VlForConditionalGeneration

>>> model = Lfm2VlForConditionalGeneration.from_pretrained("LiquidAI/LFM2-VL-1.6B")
>>> processor = AutoProcessor.from_pretrained("LiquidAI/LFM2-VL-1.6B")

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