# MobileViTV2

## Visão geral

O modelo MobileViTV2 foi proposto em [Separable Self-attention for Mobile Vision Transformers](https://huggingface.co/papers/2206.02680) por Sachin Mehta e Mohammad Rastegari.

MobileViTV2 é a segunda versão do MobileViT, construída substituindo a autoatenção multi-cabeça do MobileViT pela autoatenção separável.

O resumo do artigo é o seguinte:

*Os Mobile vision transformers (MobileViT) podem alcançar desempenho de estado da arte em várias tarefas de visão móvel, incluindo classificação e detecção. Embora esses modelos tenham menos parâmetros, apresentam alta latência em comparação com modelos baseados em redes neurais convolucionais. O principal gargalo de eficiência no MobileViT é a autoatenção multi-cabeça (MHA) nos transformers, que requer complexidade de tempo O(k2) em relação ao número de tokens (ou patches) k. Além disso, a MHA requer operações custosas (por exemplo, multiplicação de matrizes em lote) para calcular a autoatenção, impactando a latência em dispositivos com recursos limitados. Este artigo introduz um método de autoatenção separável com complexidade linear, ou seja, O(k). Uma característica simples, porém eficaz, do método proposto é que ele usa operações elemento a elemento para calcular a autoatenção, tornando-o uma boa escolha para dispositivos com recursos limitados. O modelo aprimorado, MobileViTV2, é de estado da arte em várias tarefas de visão móvel, incluindo a classificação de objetos no ImageNet e a detecção de objetos no MS-COCO. Com cerca de três milhões de parâmetros, o MobileViTV2 atinge uma precisão top-1 de 75,6% no conjunto de dados ImageNet, superando o MobileViT em cerca de 1% enquanto executa 3,2× mais rápido em um dispositivo móvel.*

Este modelo foi contribuído por [shehan97](https://huggingface.co/shehan97). O código original pode ser encontrado [aqui](https://github.com/apple/ml-cvnets).

## Dicas de uso

- MobileViTV2 é mais parecido com uma CNN do que com um modelo Transformer. Ele não funciona com dados sequenciais, mas com lotes de imagens. Diferentemente do ViT, não há embeddings. O modelo de backbone produz um mapa de características.
- É possível usar [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor) para preparar as imagens para o modelo. Observe que, se você fizer o próprio pré-processamento, os checkpoints pré-treinados esperam que as imagens estejam na ordem de pixels BGR (não RGB).
- Os checkpoints de classificação de imagem disponíveis são pré-treinados no [ImageNet-1k](https://huggingface.co/datasets/ILSVRC/imagenet-1k) (também referido como ILSVRC 2012, uma coleção de 1,3 milhão de imagens e 1.000 classes).
- O modelo de segmentação utiliza um cabeçalho [DeepLabV3](https://huggingface.co/papers/1706.05587). Os checkpoints de segmentação semântica disponíveis foram pré-treinados no [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/).

## MobileViTV2Config[[transformers.MobileViTV2Config]]

#### transformers.MobileViTV2Config[[transformers.MobileViTV2Config]]

```python
transformers.MobileViTV2Config(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, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 256, patch_size: int | list[int] | tuple[int, int] = 2, expand_ratio: float = 2.0, hidden_act: str = 'swish', conv_kernel_size: int = 3, output_stride: int = 32, classifier_dropout_prob: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, aspp_out_channels: int = 512, atrous_rates: list[int] | tuple[int, ...] = (6, 12, 18), aspp_dropout_prob: float | int = 0.1, semantic_loss_ignore_index: int = 255, n_attn_blocks: list[int] | tuple[int, ...] = (2, 4, 3), base_attn_unit_dims: list[int] | tuple[int, ...] = (128, 192, 256), width_multiplier: float | int = 1.0, ffn_multiplier: int = 2, attn_dropout: float | int = 0.0, ffn_dropout: float | int = 0.0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/configuration_mobilevitv2.py#L24)

**Parâmetros:**

num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `256`) : O tamanho (resolução) de cada imagem.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `2`) : O tamanho (resolução) de cada patch.

expand_ratio (`float`, *opcional*, padrão `2.0`) : Razão de expansão para definir as dimensões de saída da expansão

hidden_act (`str`, *opcional*, padrão `swish`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

conv_kernel_size (`int`, *opcional*, padrão `3`) : O tamanho do kernel de convolução.

output_stride (`int`, *opcional*, padrão `32`) : A proporção entre a resolução espacial dos mapas de recursos de entrada e de saída.

classifier_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para o classificador.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

aspp_out_channels (`int`, *opcional*, padrão 512) : Número de canais de saída usados na camada ASPP para segmentação semântica.

atrous_rates (`list[int]`, *opcional*, padrão `[6, 12, 18]`) : Fatores de dilatação (atrous) usados na camada ASPP para segmentação semântica.

aspp_dropout_prob (`float`, *opcional*, padrão 0.1) : A taxa de dropout para a camada ASPP para segmentação semântica.

semantic_loss_ignore_index (`int`, *opcional*, padrão `255`) : O índice que é ignorado pela função de perda do modelo de segmentação semântica.

n_attn_blocks (`list[int]`, *opcional*, padrão `[2, 4, 3]`) : O número de blocos de atenção em cada MobileViTV2Layer

base_attn_unit_dims (`list[int]`, *opcional*, padrão `[128, 192, 256]`) : O multiplicador base para as dimensões dos blocos de atenção em cada MobileViTV2Layer

width_multiplier (`float`, *opcional*, padrão 1.0) : O multiplicador de largura para MobileViTV2.

ffn_multiplier (`int`, *opcional*, padrão 2) : O multiplicador de FFN para MobileViTV2.

attn_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

ffn_dropout (`float`, *opcional*, padrão 0.0) : O dropout entre as camadas FFN.

Esta é a classe de configuração para armazenar a configuração de um MobileViTV2Model. Ela é usada para instanciar um modelo Mobilevitv2 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 [apple/mobilevitv2-1.0](https://huggingface.co/apple/mobilevitv2-1.0)

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.

Exemplo:

```python
>>> from transformers import MobileViTV2Config, MobileViTV2Model

>>> # Initializing a mobilevitv2-small style configuration
>>> configuration = MobileViTV2Config()

>>> # Initializing a model from the mobilevitv2-small style configuration
>>> model = MobileViTV2Model(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## MobileViTV2Model[[transformers.MobileViTV2Model]]

#### transformers.MobileViTV2Model[[transformers.MobileViTV2Model]]

```python
transformers.MobileViTV2Model(config: MobileViTV2Config, expand_output: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/modeling_mobilevitv2.py#L590)

**Parâmetros:**

config ([MobileViTV2Config](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2Config)) : 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.

expand_output (`bool`, *opcional*, padrão `True`) : Se deve expandir a saída do modelo. Se `True`, o modelo sairá com recursos agrupados além dos estados ocultos. Se `False`, apenas os estados ocultos serão retornados.

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

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.MobileViTV2Model.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/modeling_mobilevitv2.py#L619)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor). Veja [MobileViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor) para processar imagens).

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

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

Um `BaseModelOutputWithPoolingAndNoAttention` 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 ([MobileViTV2Config](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2Config)) e das entradas.

O método forward do [MobileViTV2Model](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2Model) substitui o método especial `__call__`.

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

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- 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 após uma operação de pooling nas dimensões espaciais.
- **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, num_channels, height, width)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

Exemplo:

```python
```

## MobileViTV2ForImageClassification[[transformers.MobileViTV2ForImageClassification]]

#### transformers.MobileViTV2ForImageClassification[[transformers.MobileViTV2ForImageClassification]]

```python
transformers.MobileViTV2ForImageClassification(config: MobileViTV2Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/modeling_mobilevitv2.py#L669)

**Parâmetros:**

config ([MobileViTV2Config](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2Config)) : 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.

Modelo MobileViTV2 com uma cabeça de classificação de imagem no topo (uma camada linear no topo dos recursos agregados), por exemplo, para ImageNet.

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.MobileViTV2ForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/modeling_mobilevitv2.py#L687)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor). Veja [MobileViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor) para processar imagens).

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de imagem. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada).

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

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

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

O método forward de [MobileViTV2ForImageClassification](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2ForImageClassification) substitui o método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada estágio) de forma `(batch_size, num_channels, height, width)`. Estados ocultos (também chamados de mapas de características) do modelo na saída de cada estágio.

Exemplo:

```python
>>> from transformers import AutoImageProcessor, MobileViTV2ForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0")
>>> model = MobileViTV2ForImageClassification.from_pretrained("apple/mobilevitv2-1.0")

>>> inputs = image_processor(image, return_tensors="pt")

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...
```

## MobileViTV2ForSemanticSegmentation[[transformers.MobileViTV2ForSemanticSegmentation]]

#### transformers.MobileViTV2ForSemanticSegmentation[[transformers.MobileViTV2ForSemanticSegmentation]]

```python
transformers.MobileViTV2ForSemanticSegmentation(config: MobileViTV2Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/modeling_mobilevitv2.py#L838)

**Parâmetros:**

config ([MobileViTV2Config](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2Config)) : 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.

Modelo MobileViTV2 com uma cabeça de segmentação semântica no topo, por exemplo, para Pascal VOC.

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.MobileViTV2ForSemanticSegmentation.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilevitv2/modeling_mobilevitv2.py#L849)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor). Veja [MobileViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [MobileViTImageProcessor](/docs/transformers/main/pt/model_doc/mobilevit#transformers.MobileViTImageProcessor) para processar imagens).

labels (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Mapas de segmentação semântica de verdade para o cálculo da perda. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels > 1`, uma perda de classificação é calculada (Cross-Entropy).

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

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

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

O método forward de [MobileViTV2ForSemanticSegmentation](/docs/transformers/main/pt/model_doc/mobilevitv2#transformers.MobileViTV2ForSemanticSegmentation) substitui o método especial `__call__`.

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

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels, logits_height, logits_width)`) -- Pontuações de classificação para cada pixel.

  

  Os logits retornados não necessariamente têm o mesmo tamanho que os `pixel_values` passados como entradas. Isso é para evitar realizar duas interpolações e perder alguma qualidade quando um usuário precisa redimensionar os logits para o tamanho da imagem original como pós-processamento. Você deve sempre verificar a forma dos seus logits e redimensioná-los conforme necessário.

  
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, patch_size, 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` (uma para cada camada) de forma `(batch_size, num_heads, patch_size, sequence_length)`.

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

Exemplos:

```python
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch
>>> from PIL import Image
>>> from transformers import AutoImageProcessor, MobileViTV2ForSemanticSegmentation

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")
>>> model = MobileViTV2ForSemanticSegmentation.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256")

>>> inputs = image_processor(images=image, return_tensors="pt")

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

>>> # logits are of shape (batch_size, num_labels, height, width)
>>> logits = outputs.logits
```