# EdgeTAM

## Visão geral

O modelo EdgeTAM foi proposto em [EdgeTAM: On-Device Track Anything Model](https://huggingface.co/papers/2501.07256) Chong Zhou, Chenchen Zhu, Yunyang Xiong, Saksham Suri, Fanyi Xiao, Lemeng Wu, Raghuraman Krishnamoorthi, Bo Dai, Chen Change Loy, Vikas Chandra, Bilge Soran.

EdgeTAM é uma adaptação eficiente do SAM 2 que introduz uma arquitetura 2D Spatial Perceiver para otimizar os mecanismos de atenção de memória para segmentação de vídeo em tempo real em dispositivos móveis.

O resumo do artigo é o seguinte:

*Além do Segment Anything Model (SAM), o SAM 2 estende ainda mais sua capacidade de imagens para entradas de vídeo por meio de um mecanismo de banco de memória e obtém um desempenho notável em comparação com métodos anteriores, tornando-o um modelo de base para a tarefa de segmentação de vídeo. Neste artigo, nosso objetivo é tornar o SAM 2 muito mais eficiente, de modo que ele possa ser executado em dispositivos móveis mantendo um desempenho comparável. Apesar de vários trabalhos que otimizam o SAM para uma melhor eficiência, constatamos que eles não são suficientes para o SAM 2, pois todos se concentram na compressão do codificador de imagem, enquanto nosso benchmark mostra que os novos blocos de atenção de memória introduzidos também são o gargalo de latência. Dada essa observação, propomos o EdgeTAM, que utiliza um novo 2D Spatial Perceiver para reduzir o custo computacional. Em particular, o 2D Spatial Perceiver proposto codifica as memórias de nível de quadro armazenadas de forma densa com um Transformer leve que contém um conjunto fixo de consultas aprendíveis. Dado que a segmentação de vídeo é uma tarefa de predição densa, constatamos que preservar a estrutura espacial das memórias é essencial, de modo que as consultas são divididas em grupos de nível global e de nível de patch. Também propomos um pipeline de destilação que melhora ainda mais o desempenho sem sobrecarga de inferência. Como resultado, o EdgeTAM alcança 87,7, 70,0, 72,3 e 71,7 J&F em DAVIS 2017, MOSE, SA-V val e SA-V test, enquanto é executado a 16 FPS no iPhone 15 Pro Max.*

Este modelo foi contribuído por [yonigozlan](https://huggingface.co/yonigozlan). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/EdgeTAM).

## Exemplo de uso

### Geração automática de máscaras com Pipeline

O EdgeTAM pode ser usado para geração automática de máscaras, segmentando todos os objetos em uma imagem usando o pipeline `mask-generation`:

```python
from transformers import pipeline

generator = pipeline("mask-generation", model="yonigozlan/edgetam-1", device=0)
image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
outputs = generator(image_url, points_per_batch=64)

len(outputs["masks"])  # Number of masks generated
39
```

### Segmentação Básica de Imagens

#### Clique em um único ponto

Você pode segmentar objetos fornecendo um único clique no objeto que deseja segmentar:

```python
from transformers import Sam2Processor, EdgeTamModel
import torch
from PIL import Image
import requests

model = EdgeTamModel.from_pretrained("yonigozlan/edgetam-1", device_map="auto")
processor = Sam2Processor.from_pretrained("yonigozlan/edgetam-1")

image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
raw_image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

input_points = [[[[500, 375]]]]  # Single point click, 4 dimensions (image_dim, object_dim, point_per_object_dim, coordinates)
input_labels = [[[1]]]  # 1 for positive click, 0 for negative click, 3 dimensions (image_dim, object_dim, point_label)

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]

# The model outputs multiple mask predictions ranked by quality score
print(f"Generated {masks.shape[1]} masks with shape {masks.shape}")
Generated 3 masks with shape torch.Size([1, 3, 1200, 1800])
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.0463, 0.4859, 0.7616], device='cuda:0')
```

#### Vários pontos para refinamento

Você pode fornecer vários pontos para refinar a segmentação:

```python
# Add both positive and negative points to refine the mask
input_points = [[[[500, 375], [1125, 625]]]]  # Multiple points for refinement
input_labels = [[[1, 1]]]  # Both positive clicks

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.8362, 0.6900, 0.2120], device='cuda:0')
```

#### Entrada de Bounding Box

O EdgeTAM também suporta entradas de bounding box para segmentação:

```python
# Define bounding box as [x_min, y_min, x_max, y_max]
input_boxes = [[[75, 275, 1725, 850]]]

inputs = processor(images=raw_image, input_boxes=input_boxes, return_tensors="pt").to(model.device)

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

masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.9301, 0.9348, 0.6605], device='cuda:0')
```

#### Segmentação de múltiplos objetos

Você pode segmentar vários objetos simultaneamente:

```python
# Define points for two different objects
input_points = [[[[500, 375]], [[650, 750]]]]  # Points for two objects in same image
input_labels = [[[1], [1]]]  # Positive clicks for both objects

inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

# Each object gets its own mask
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"Generated masks for {masks.shape[0]} objects")
Generated masks for 2 objects
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.7616, 0.9465], device='cuda:0')
```

### Inferência em Lote

#### Imagens em Lote

Processe várias imagens simultaneamente para melhorar a eficiência:

```python
from transformers import Sam2Processor, EdgeTamModel
import torch
from PIL import Image
import requests

model = EdgeTamModel.from_pretrained("yonigozlan/edgetam-1", device_map="auto")
processor = Sam2Processor.from_pretrained("yonigozlan/edgetam-1")

# Load multiple images
image_urls = [
    "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg",
    "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dog_sam.png"
]
raw_images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]

# Single point per image
input_points = [[[[500, 375]]], [[[770, 200]]]]  # One point for each image
input_labels = [[[1]], [[1]]]  # Positive clicks for both images

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

# Post-process masks for each image
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(all_masks)} images, each with {all_masks[0].shape[0]} objects")
Processed 2 images, each with 1 objects
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.7618, 0.7999], device='cuda:0')
```

#### Objetos em lote por imagem

Segmente múltiplos objetos em cada imagem usando inferência em lote:

```python
# Multiple objects per image - different numbers of objects per image
input_points = [
    [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects
    [[[770, 200]]]  # Dog image: 1 object
]
input_labels = [
    [[1], [1]],  # Truck image: positive clicks for both objects
    [[1]]  # Dog image: positive click for the object
]

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
```

#### Imagens em lote com objetos em lote e múltiplos pontos

Trate cenários complexos de lote com múltiplos pontos por objeto:

```python
# Add groceries image for more complex example
groceries_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/groceries.jpg"
groceries_image = Image.open(requests.get(groceries_url, stream=True).raw).convert("RGB")
raw_images = [raw_images[0], groceries_image]  # Use truck and groceries images

# Complex batching: multiple images, multiple objects, multiple points per object
input_points = [
    [[[500, 375]], [[650, 750]]],  # Truck image: 2 objects with 1 point each
    [[[400, 300]], [[630, 300], [550, 300]]]  # Groceries image: obj1 has 1 point, obj2 has 2 points
]
input_labels = [
    [[1], [1]],  # Truck image: positive clicks
    [[1], [1, 1]]  # Groceries image: positive clicks for refinement
]

inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
```

#### Caixas Delimitadoras em Lote

Processe várias imagens com entradas de bounding box:

```python
# Multiple bounding boxes per image (using truck and groceries images)
input_boxes = [
    [[75, 275, 1725, 850], [425, 600, 700, 875], [1375, 550, 1650, 800], [1240, 675, 1400, 750]],  # Truck image: 4 boxes
    [[450, 170, 520, 350], [350, 190, 450, 350], [500, 170, 580, 350], [580, 170, 640, 350]]  # Groceries image: 4 boxes
]

# Update images for this example
raw_images = [raw_images[0], groceries_image]  # truck and groceries

inputs = processor(images=raw_images, input_boxes=input_boxes, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs, multimask_output=False)

all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(input_boxes)} images with {len(input_boxes[0])} and {len(input_boxes[1])} boxes respectively")
Processed 2 images with 4 and 4 boxes respectively
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.9301, 0.9348, 0.6605, 0.9465], device='cuda:0')
```

### Usando Máscaras Anteriores como Entrada

O EdgeTAM pode usar máscaras de previsões anteriores como entrada para refinar a segmentação:

```python
# Get initial segmentation
input_points = [[[[500, 375]]]]
input_labels = [[[1]]]
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)

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

# Use the best mask as input for refinement
mask_input = outputs.pred_masks[:, :, torch.argmax(outputs.iou_scores.squeeze())]

# Add additional points with the mask input
new_input_points = [[[[500, 375], [450, 300]]]]
new_input_labels = [[[1, 1]]]
inputs = processor(
    input_points=new_input_points,
    input_labels=new_input_labels,
    original_sizes=inputs["original_sizes"],
    return_tensors="pt",
).to(model.device)

with torch.no_grad():
    refined_outputs = model(
        **inputs,
        input_masks=mask_input,
        image_embeddings=outputs.image_embeddings,
        multimask_output=False,
    )
```

## EdgeTamConfig[[transformers.EdgeTamConfig]]

#### transformers.EdgeTamConfig[[transformers.EdgeTamConfig]]

```python
transformers.EdgeTamConfig(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, prompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L152)

**Parâmetros:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão.

prompt_encoder_config (Union[`dict`, `EdgeTamPromptEncoderConfig`], *opcional*) : Dicionário de opções de configuração usadas para inicializar [EdgeTamPromptEncoderConfig](/docs/transformers/main/pt/model_doc/edgetam#transformers.EdgeTamPromptEncoderConfig).

mask_decoder_config (Union[`dict`, `EdgeTamMaskDecoderConfig`], *opcional*) : Dicionário de opções de configuração usadas para inicializar [EdgeTamMaskDecoderConfig](/docs/transformers/main/pt/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig).

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

Esta é a classe de configuração para armazenar a configuração de um EdgeTamModel. Ela é usada para instanciar um modelo Edgetam 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 [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

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 (
...     EdgeTamVisionConfig,
...     EdgeTamPromptEncoderConfig,
...     EdgeTamMaskDecoderConfig,
...     EdgeTamModel,
... )

>>> # Initializing a EdgeTamConfig with `"facebook/edgetam.1_hiera_tiny"` style configuration
>>> configuration = EdgeTamConfig()

>>> # Initializing a EdgeTamModel (with random weights) from the `"facebook/edgetam.1_hiera_tiny"` style configuration
>>> model = EdgeTamModel(configuration)

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

>>> # We can also initialize a EdgeTamConfig from a EdgeTamVisionConfig, EdgeTamPromptEncoderConfig, and EdgeTamMaskDecoderConfig
>>> # Initializing EDGETAM vision encoder, memory attention, and memory encoder configurations
>>> vision_config = EdgeTamVisionConfig()
>>> prompt_encoder_config = EdgeTamPromptEncoderConfig()
>>> mask_decoder_config = EdgeTamMaskDecoderConfig()

>>> config = EdgeTamConfig(vision_config, prompt_encoder_config, mask_decoder_config)
```

## EdgeTamVisionConfig[[transformers.EdgeTamVisionConfig]]

#### transformers.EdgeTamVisionConfig[[transformers.EdgeTamVisionConfig]]

```python
transformers.EdgeTamVisionConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, backbone_channel_list: list[int] | None = None, backbone_feature_sizes: list | None = None, fpn_hidden_size: int = 256, fpn_kernel_size: int = 1, fpn_stride: int = 1, fpn_padding: int = 0, fpn_top_down_levels: list[int] | None = None, num_feature_levels: int = 3, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, initializer_range: float = 0.02)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L29)

**Parâmetros:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone.

backbone_channel_list (`List[int]`, *opcional*, padrão `[384, 192, 96, 48]`) : A lista de dimensões de canais para o backbone.

backbone_feature_sizes (`List[List[int]]`, *opcional*, padrão `[[256, 256], [128, 128], [64, 64]]`) : Os tamanhos espaciais dos mapas de características vindos do backbone.

fpn_hidden_size (`int`, *opcional*, padrão 256) : A dimensão oculta do FPN.

fpn_kernel_size (`int`, *opcional*, padrão 1) : O tamanho do kernel para as convoluções no neck.

fpn_stride (`int`, *opcional*, padrão 1) : O stride das convoluções no neck.

fpn_padding (`int`, *opcional*, padrão 0) : O padding para as convoluções no neck.

fpn_top_down_levels (`List[int]`, *opcional*, padrão `[2, 3]`) : Os níveis para as conexões FPN de cima para baixo.

num_feature_levels (`int`, *opcional*, padrão 3) : O número de níveis de recursos do FPN a serem usados.

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

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

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

Esta é a classe de configuração para armazenar a configuração de um EdgeTamModel. Ela é usada para instanciar um modelo Edgetam 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 [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

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.

## EdgeTamMaskDecoderConfig[[transformers.EdgeTamMaskDecoderConfig]]

#### transformers.EdgeTamMaskDecoderConfig[[transformers.EdgeTamMaskDecoderConfig]]

```python
transformers.EdgeTamMaskDecoderConfig(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, hidden_size: int = 256, hidden_act: str = 'gelu', mlp_dim: int = 2048, num_hidden_layers: int = 2, num_attention_heads: int = 8, attention_downsample_rate: int = 2, num_multimask_outputs: int = 3, iou_head_depth: int = 3, iou_head_hidden_dim: int = 256, dynamic_multimask_via_stability: bool = True, dynamic_multimask_stability_delta: float = 0.05, dynamic_multimask_stability_thresh: float = 0.98)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L113)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

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

mlp_dim (`int`, *opcional*, padrão 2048) : A dimensão do MLP no transformer bidirecional.

num_hidden_layers (`int`, *opcional*, padrão `2`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

attention_downsample_rate (`int`, *opcional*, padrão 2) : A taxa de downsampling para as camadas de atenção.

num_multimask_outputs (`int`, *opcional*, padrão 3) : O número de saídas multimask.

iou_head_depth (`int`, *opcional*, padrão 3) : A profundidade da cabeça de IoU.

iou_head_hidden_dim (`int`, *opcional*, padrão 256) : A dimensão oculta da cabeça de IoU.

dynamic_multimask_via_stability (`bool`, *opcional*, padrão `True`) : Se deve usar a multimáscara dinâmica via estabilidade.

dynamic_multimask_stability_delta (`float`, *opcional*, padrão 0.05) : O delta de estabilidade para a multimáscara dinâmica.

dynamic_multimask_stability_thresh (`float`, *opcional*, padrão 0.98) : O limiar de estabilidade para a multimáscara dinâmica.

Esta é a classe de configuração para armazenar a configuração de um EdgeTamModel. Ela é usada para instanciar um modelo Edgetam 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 [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

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.

## EdgeTamPromptEncoderConfig[[transformers.EdgeTamPromptEncoderConfig]]

#### transformers.EdgeTamPromptEncoderConfig[[transformers.EdgeTamPromptEncoderConfig]]

```python
transformers.EdgeTamPromptEncoderConfig(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, hidden_size: int = 256, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, mask_input_channels: int = 16, num_point_embeddings: int = 4, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, scale: int = 1)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/configuration_edgetam.py#L88)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

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

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

mask_input_channels (`int`, *opcional*, padrão 16) : O número de canais a serem enviados para o módulo `MaskDecoder`.

num_point_embeddings (`int`, *opcional*, padrão 4) : O número de embeddings de pontos a serem usados.

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

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

scale (`float`, *opcional*, padrão 1) : O fator de escala para o codificador de prompt.

Esta é a classe de configuração para armazenar a configuração de um EdgeTamModel. Ela é usada para instanciar um modelo Edgetam 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 [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

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.

## EdgeTamVisionModel[[transformers.EdgeTamVisionModel]]

#### transformers.EdgeTamVisionModel[[transformers.EdgeTamVisionModel]]

```python
transformers.EdgeTamVisionModel(config: EdgeTamVisionConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L452)

**Parâmetros:**

config ([EdgeTamVisionConfig](/docs/transformers/main/pt/model_doc/edgetam#transformers.EdgeTamVisionConfig)) : 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 de visão do EdgeTAM, sem nenhum head ou projeção 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.EdgeTamVisionModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L470)

## EdgeTamModel[[transformers.EdgeTamModel]]

#### transformers.EdgeTamModel[[transformers.EdgeTamModel]]

```python
transformers.EdgeTamModel(config: EdgeTamConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L945)

**Parâmetros:**

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

Segment Anything Model 2 (SAM 2) para gerar máscaras de segmentação, dado uma imagem de entrada e pontos e rótulos, caixas ou máscaras de entrada.

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

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, input_points: typing.Optional[torch.Tensor] = None, input_labels: typing.Optional[torch.LongTensor] = None, input_boxes: typing.Optional[torch.Tensor] = None, input_masks: typing.Optional[torch.LongTensor] = None, image_embeddings: typing.Optional[torch.Tensor] = None, multimask_output: bool = True, attention_similarity: typing.Optional[torch.Tensor] = None, target_embedding: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L1051)

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

input_points (`torch.Tensor` de forma `(batch_size, num_points, 2)`) : Pontos espaciais 2D de entrada, usados pelo codificador de prompt para codificar o prompt. Geralmente, isso resulta em muito melhores resultados. Os pontos podem ser obtidos passando uma lista de listas de listas para o processador, que criará os correspondentes `torch` tensores de dimensão 4. A primeira dimensão é o tamanho do lote de imagens, a segunda dimensão é o tamanho do lote de pontos (ou seja, quantas máscaras de segmentação queremos que o modelo preveja por ponto de entrada), a terceira dimensão é o número de pontos por máscara de segmentação (é possível passar múltiplos pontos para uma única máscara) e a última dimensão são as coordenadas x (vertical) e y (horizontal) do ponto. Se um número diferente de pontos for passado para cada imagem ou para cada máscara, o processador criará pontos "PAD" que corresponderão à coordenada (0, 0), e o cálculo do embedding será ignorado para esses pontos usando os rótulos.

input_labels (`torch.LongTensor` de forma `(batch_size, point_batch_size, num_points)`) : Rótulos de entrada para os pontos, usados pelo codificador de prompt para codificar o prompt. De acordo com a implementação oficial, existem 3 tipos de rótulos  - `1`: o ponto contém o objeto de interesse - `0`: o ponto não contém o objeto de interesse - `-1`: o ponto corresponde ao fundo  Adicionamos o rótulo:  - `-10`: o ponto é um ponto de preenchimento (padding) e, portanto, deve ser ignorado pelo codificador de prompt  Os rótulos de preenchimento devem ser aplicados automaticamente pelo processador.

input_boxes (`torch.Tensor` de forma `(batch_size, num_boxes, 4)`) : Caixas de entrada para os pontos, usadas pelo codificador de prompt para codificar o prompt. Geralmente resulta em máscaras geradas muito melhores. As caixas podem ser obtidas passando uma lista de listas de listas para o processador, que gerará um tensor `torch`, com cada dimensão correspondendo, respectivamente, ao tamanho do lote de imagens, ao número de caixas por imagem e às coordenadas do ponto superior esquerdo e do ponto inferior direito da caixa. Na ordem (`x1`, `y1`, `x2`, `y2`):  - `x1`: a coordenada x do ponto superior esquerdo da caixa de entrada - `y1`: a coordenada y do ponto superior esquerdo da caixa de entrada - `x2`: a coordenada x do ponto inferior direito da caixa de entrada - `y2`: a coordenada y do ponto inferior direito da caixa de entrada

input_masks (`torch.Tensor` de forma `(batch_size, image_size, image_size)`) : O modelo SAM também aceita máscaras de segmentação como entrada. A máscara será incorporada pelo codificador de prompt para gerar uma incorporação correspondente, que será fornecida posteriormente ao decodificador de máscara. Essas máscaras precisam ser fornecidas manualmente pelo usuário e precisam ter a forma (`batch_size`, `image_size`, `image_size`).

image_embeddings (`torch.Tensor` de forma `(batch_size, output_channels, window_size, window_size)`) : Embebimentos de imagem, usados pelo decodificador de máscaras para gerar máscaras e pontuações de iou. Para um cálculo mais eficiente em termos de memória, os usuários podem primeiro recuperar os embebimentos de imagem usando o método `get_image_embeddings` e, em seguida, fornecê-los ao método `forward` em vez de fornecer os `pixel_values`.

multimask_output (`bool`, *opcional*) : Na implementação e no artigo originais, o modelo sempre produz 3 máscaras por imagem (ou por ponto / por bounding box, quando aplicável). No entanto, é possível produzir apenas uma única máscara, que corresponde à máscara "melhor", especificando `multimask_output=False`.

attention_similarity (`torch.Tensor`, *opcional*) : Tensor de similaridade de atenção, a ser fornecido ao decodificador de máscara para atenção guiada por alvo, caso o modelo seja usado para personalização, conforme introduzido em [PerSAM](https://huggingface.co/papers/2305.03048).

target_embedding (`torch.Tensor`, *opcional*) : Incorporação do conceito-alvo, a ser fornecida ao decodificador de máscara para prompting semântico-alvo, caso o modelo seja usado para personalização, conforme introduzido em [PerSAM](https://huggingface.co/papers/2305.03048).

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

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

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

- **iou_scores** (`torch.Tensor` de forma `(batch_size, point_batch_size, num_masks)`) -- As pontuações de Interseção sobre União (IoU) das máscaras previstas.
- **pred_masks** (`torch.Tensor` de forma `(batch_size, point_batch_size, num_masks, height, width)`) -- As máscaras de baixa resolução previstas. Este é um alias para `low_res_masks`. Essas máscaras precisam ser pós-processadas pelo processor para serem trazidas ao tamanho original da imagem.
- **object_score_logits** (`torch.Tensor` de forma `(batch_size, point_batch_size, 1)`) -- Logits para a pontuação do objeto, indicando se um objeto está presente.
- **image_embeddings** (`tuple(torch.Tensor)`) -- Os recursos do FPN, que são usados pelo decodificador de máscaras. Esta é uma tupla de `torch.Tensor` em que cada tensor tem a forma `(batch_size, channels, height, width)`.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída de cada estágio) com forma `(batch_size, height, width, hidden_size)`. Estados ocultos do modelo de visão na saída de cada estágio.
- **vision_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `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 do modelo de visão.
- **mask_decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `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 do decodificador de máscara.

Exemplo:

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

>>> model = AutoModel.from_pretrained("danelcsb/edgetam.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/edgetam.1_hiera_tiny")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     raw_image = Image.open(BytesIO(response.read())).convert("RGB")
>>> input_points = [[[400, 650]]]  # 2D location of a window on the car
>>> inputs = processor(images=raw_image, input_points=input_points, return_tensors="pt")

>>> # Get segmentation mask
>>> outputs = model(**inputs)

>>> # Postprocess masks
>>> masks = processor.post_process_masks(
...     outputs.pred_masks, inputs["original_sizes"]
... )
```

#### get_image_features[[transformers.EdgeTamModel.get_image_features]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/edgetam/modeling_edgetam.py#L1229)

**Parâmetros:**

pixel_values (`torch.Tensor`) : Valores de pixels de entrada com forma `(batch_size, num_channels, height, width)`.

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

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

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, height, width, 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.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- Tupla de `torch.Tensor` (um para cada nível de recurso, da resolução mais alta para a mais baixa) com forma `(batch_size, hidden_size, height, width)`. Mapas de recursos do pescoço da Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- Tupla de `torch.Tensor` (um para cada nível de recurso, da resolução mais alta para a mais baixa) com forma `(batch_size, hidden_size, height, width)`. Codificações posicionais correspondentes às `fpn_hidden_states`.

Exemplo:

```python
```