# EdgeTAM

## Ikhtisar

Model EdgeTAM diusulkan dalam [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 adalah adaptasi efisien dari SAM 2 yang memperkenalkan arsitektur 2D Spatial Perceiver untuk mengoptimalkan mekanisme perhatian memori bagi segmentasi video real-time pada perangkat mobile.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Di atas Segment Anything Model (SAM), SAM 2 lebih lanjut memperluas kemampuannya dari input gambar ke input video melalui mekanisme memory bank dan memperoleh kinerja yang luar biasa dibandingkan dengan metode sebelumnya, menjadikannya model fondasi untuk tugas segmentasi video. Dalam makalah ini, kami bertujuan untuk membuat SAM 2 jauh lebih efisien sehingga bahkan dapat berjalan pada perangkat seluler sambil mempertahankan kinerja yang sebanding. Meskipun ada beberapa karya yang mengoptimalkan SAM untuk efisiensi yang lebih baik, kami menemukan bahwa mereka tidak cukup untuk SAM 2 karena semuanya berfokus pada kompresi image encoder, sementara benchmark kami menunjukkan bahwa blok memory attention yang baru diperkenalkan juga merupakan bottleneck latensi. Mengingat observasi ini, kami mengusulkan EdgeTAM, yang memanfaatkan 2D Spatial Perceiver baru untuk mengurangi biaya komputasi. Secara khusus, 2D Spatial Perceiver yang diusulkan mengkodekan memori tingkat frame yang disimpan secara padat dengan Transformer ringan yang berisi himpunan tetap dari query yang dapat dipelajari. Mengingat segmentasi video adalah tugas prediksi padat, kami menemukan bahwa mempertahankan struktur spasial dari memori sangat penting sehingga query dipecah menjadi kelompok tingkat global dan tingkat patch. Kami juga mengusulkan pipeline distilasi yang lebih lanjut meningkatkan kinerja tanpa overhead inferensi. Akibatnya, EdgeTAM mencapai 87,7, 70,0, 72,3, dan 71,7 J&F pada DAVIS 2017, MOSE, SA-V val, dan SA-V test, sambil berjalan pada 16 FPS di iPhone 15 Pro Max.*

Model ini disumbangkan oleh [yonigozlan](https://huggingface.co/yonigozlan). Kode aslinya dapat ditemukan [di sini](https://github.com/facebookresearch/EdgeTAM).

## Contoh penggunaan

### Generasi Mask Otomatis dengan Pipeline

EdgeTAM dapat digunakan untuk pembuatan maska otomatis guna memsegmentasi semua objek dalam gambar menggunakan 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
```

### Segmentasi Gambar Dasar

#### Klik Titik Tunggal

Anda dapat memsegmentasi objek dengan memberikan satu kali klik pada objek yang ingin Anda segmentasi:

```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')
```

#### Beberapa Poin untuk Penyempurnaan

Anda dapat memberikan beberapa titik untuk menyempurnakan segmentasi:

```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')
```

#### Input Kotak Batas

EdgeTAM juga mendukung input kotak pembatas untuk segmentasi:

```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')
```

#### Segmentasi Objek Ganda

Anda dapat memsegmentasikan beberapa objek secara bersamaan:

```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')
```

### Inferensi Batch

#### Gambar Berbatch

Proses beberapa gambar secara bersamaan untuk efisiensi yang lebih baik:

```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')
```

#### Objek Batch per Gambar

Segmentasikan beberapa objek di dalam setiap gambar menggunakan inferensi batch:

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

#### Gambar Berbatch dengan Objek Berbatch dan Beberapa Titik

Atasi skenario batch kompleks dengan beberapa titik per objek:

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

#### Kotak Batas Berbatch

Proses beberapa gambar dengan input kotak pembatas:

```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')
```

### Menggunakan Masker Sebelumnya sebagai Input

EdgeTAM dapat menggunakan mask dari prediksi sebelumnya sebagai input untuk menyempurnakan segmentasi:

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

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

**Parameter:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari vision backbone.

prompt_encoder_config (Union[`dict`, `EdgeTamPromptEncoderConfig`], *opsional*) : Kamus opsi konfigurasi yang digunakan untuk menginisialisasi [EdgeTamPromptEncoderConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamPromptEncoderConfig).

mask_decoder_config (Union[`dict`, `EdgeTamMaskDecoderConfig`], *optional*) : Kamus opsi konfigurasi yang digunakan untuk menginisialisasi [EdgeTamMaskDecoderConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamMaskDecoderConfig).

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari EdgeTamModel. Kelas ini digunakan untuk membuat instans model Edgetam berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

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

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

**Parameter:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Konfigurasi dari model backbone.

backbone_channel_list (`List[int]`, *opsional*, defaultnya `[384, 192, 96, 48]`) : Daftar dimensi channel untuk backbone.

backbone_feature_sizes (`List[List[int]]`, *opsional*, defaultnya `[[256, 256], [128, 128], [64, 64]]`) : Ukuran spasial dari peta fitur yang berasal dari backbone.

fpn_hidden_size (`int`, *opsional*, default 256) : Dimensi tersembunyi dari FPN.

fpn_kernel_size (`int`, *opsional*, defaultnya 1) : Ukuran kernel untuk konvolusi di neck.

fpn_stride (`int`, *opsional*, defaultnya 1) : Stride untuk konvolusi di neck.

fpn_padding (`int`, *opsional*, default 0) : Padding untuk konvolusi di neck.

fpn_top_down_levels (`List[int]`, *opsional*, defaultnya `[2, 3]`) : Level untuk koneksi FPN top-down.

num_feature_levels (`int`, *opsional*, defaultnya 3) : Jumlah level fitur dari FPN yang akan digunakan.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari EdgeTamModel. Kelas ini digunakan untuk membuat instans model Edgetam berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## 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)
```

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

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `256`) : Dimensi dari representasi tersembunyi.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

mlp_dim (`int`, *opsional*, defaultnya 2048) : Dimensi dari MLP dalam transformer dua arah.

num_hidden_layers (`int`, *opsional*, defaultnya `2`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

attention_downsample_rate (`int`, *opsional*, defaultnya 2) : Laju downsampling untuk lapisan attention.

num_multimask_outputs (`int`, *opsional*, defaultnya 3) : Jumlah output multimask.

iou_head_depth (`int`, *opsional*, defaultnya 3) : Kedalaman dari kepala IoU.

iou_head_hidden_dim (`int`, *opsional*, default 256) : Dimensi tersembunyi dari kepala IoU.

dynamic_multimask_via_stability (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan multimask dinamis melalui stabilitas.

dynamic_multimask_stability_delta (`float`, *opsional*, default 0.05) : Delta stabilitas untuk multimask dinamis.

dynamic_multimask_stability_thresh (`float`, *opsional*, default 0.98) : Ambang batas stabilitas untuk multimask dinamis.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari EdgeTamModel. Kelas ini digunakan untuk membuat instans model Edgetam berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## 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)
```

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

**Parameter:**

hidden_size (`int`, *opsional*, defaultnya `256`) : Dimensi dari representasi tersembunyi.

image_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `1024`) : Ukuran (resolusi) dari setiap gambar.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `16`) : Ukuran (resolusi) dari setiap patch.

mask_input_channels (`int`, *opsional*, default 16) : Jumlah channel yang akan diberikan ke modul `MaskDecoder`.

num_point_embeddings (`int`, *opsional*, defaultnya 4) : Jumlah point embedding yang akan digunakan.

hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

scale (`float`, *opsional*, default 1) : Faktor skala untuk prompt encoder.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari EdgeTamModel. Kelas ini digunakan untuk membuat instans model Edgetam berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [yonigozlan/EdgeTAM-hf](https://huggingface.co/yonigozlan/EdgeTAM-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

## EdgeTamVisionModel[[transformers.EdgeTamVisionModel]]

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

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

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

**Parameter:**

config ([EdgeTamVisionConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamVisionConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model visi dari EdgeTAM tanpa head atau proyeksi di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

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

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

[Sumber](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)
```

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

**Parameter:**

config ([EdgeTamConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Segment Anything Model 2 (SAM 2) untuk menghasilkan mask segmentasi, diberikan gambar input dan titik serta label input, kotak, atau mask.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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'>)
```

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

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`, *opsional*) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [Sam2ImageProcessor](/docs/transformers/main/id/model_doc/sam2#transformers.Sam2ImageProcessor). Lihat [Sam2ImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya ([Sam2Processor](/docs/transformers/main/id/model_doc/sam2#transformers.Sam2Processor) menggunakan [Sam2ImageProcessor](/docs/transformers/main/id/model_doc/sam2#transformers.Sam2ImageProcessor) untuk memproses gambar).

input_points (`torch.Tensor` dengan bentuk `(batch_size, num_points, 2)`) : Titik spasial 2D sebagai input, yang digunakan oleh prompt encoder untuk meng-encode prompt. Umumnya menghasilkan hasil yang jauh lebih baik. Titik-titik ini dapat diperoleh dengan meneruskan list of list of list ke processor, yang akan membuat tensor `torch` berdimensi 4 yang sesuai. Dimensi pertama adalah ukuran batch gambar, dimensi kedua adalah ukuran batch titik (yaitu berapa banyak segmentation mask yang ingin diprediksi model per titik input), dimensi ketiga adalah jumlah titik per segmentation mask (dimungkinkan untuk meneruskan beberapa titik untuk satu mask), dan dimensi terakhir adalah koordinat x (vertikal) dan y (horizontal) dari titik tersebut. Jika jumlah titik yang diteruskan berbeda untuk setiap gambar atau untuk setiap mask, processor akan membuat titik "PAD" yang akan sesuai dengan koordinat (0, 0), dan perhitungan embedding akan dilewati untuk titik-titik ini menggunakan label.

input_labels (`torch.LongTensor` dengan bentuk `(batch_size, point_batch_size, num_points)`) : Label input untuk titik-titik, yang digunakan oleh prompt encoder untuk meng-encode prompt. Menurut implementasi resmi, terdapat 3 jenis label - `1`: titik tersebut adalah titik yang mengandung objek yang diminati - `0`: titik tersebut adalah titik yang tidak mengandung objek yang diminati - `-1`: titik tersebut sesuai dengan latar belakang  Kami menambahkan label: - `-10`: titik tersebut adalah titik padding, sehingga harus diabaikan oleh prompt encoder Label padding seharusnya dilakukan secara otomatis oleh processor.

input_boxes (`torch.Tensor` dengan bentuk `(batch_size, num_boxes, 4)`) : Kotak input untuk titik-titik, yang digunakan oleh prompt encoder untuk meng-encode prompt. Umumnya menghasilkan mask yang dihasilkan jauh lebih baik. Kotak-kotak ini dapat diperoleh dengan meneruskan list of list of list ke processor, yang akan menghasilkan tensor `torch`, di mana setiap dimensi secara berturut-turut sesuai dengan ukuran batch gambar, jumlah kotak per gambar, dan koordinat titik kiri atas dan kanan bawah dari kotak. Dalam urutan (`x1`, `y1`, `x2`, `y2`):  - `x1`: koordinat x dari titik kiri atas kotak input - `y1`: koordinat y dari titik kiri atas kotak input - `x2`: koordinat x dari titik kanan bawah kotak input - `y2`: koordinat y dari titik kanan bawah kotak input

input_masks (`torch.Tensor` dengan bentuk `(batch_size, image_size, image_size)`) : Model SAM juga menerima mask segmentasi sebagai input. Mask akan di-embed oleh prompt encoder untuk menghasilkan embedding yang sesuai, yang kemudian akan diberikan ke mask decoder. Mask ini perlu diberikan secara manual oleh pengguna, dan harus memiliki bentuk (`batch_size`, `image_size`, `image_size`).

image_embeddings (`torch.Tensor` dengan bentuk `(batch_size, output_channels, window_size, window_size)`) : Embedding gambar, yang digunakan oleh mask decoder untuk menghasilkan mask dan skor iou. Untuk komputasi yang lebih hemat memori, pengguna dapat terlebih dahulu mengambil embedding gambar menggunakan metode `get_image_embeddings`, lalu memasukkannya ke metode `forward` alih-alih memasukan `pixel_values`.

multimask_output (`bool`, *opsional*) : Pada implementasi dan paper aslinya, model selalu mengoutput 3 mask per gambar (atau per titik / per bounding box jika relevan). Namun, dimungkinkan untuk hanya mengoutput satu mask yang sesuai dengan mask "terbaik" dengan menentukan `multimask_output=False`.

attention_similarity (`torch.Tensor`, *opsional*) : Tensor kemiripan perhatian, yang akan diberikan ke decoder masker untuk perhatian yang dipandu target dalam kasus model digunakan untuk personalisasi sebagaimana diperkenalkan dalam [PerSAM](https://huggingface.co/papers/2305.03048).

target_embedding (`torch.Tensor`, *opsional*) : Embedding dari konsep target, yang harus diberikan ke mask decoder untuk target-semantic prompting jika model digunakan untuk personalisasi seperti yang diperkenalkan dalam [PerSAM](https://huggingface.co/papers/2305.03048).

**Mengembalikan:** `EdgeTamImageSegmentationOutput` atau `tuple(torch.Tensor)`

`EdgeTamImageSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([EdgeTamConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamConfig)) dan input.

Metode forward dari [EdgeTamModel](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamModel) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **iou_scores** (`torch.Tensor` dengan bentuk `(batch_size, point_batch_size, num_masks)`) -- Skor Intersection over Union (IoU) dari mask yang diprediksi.
- **pred_masks** (`torch.Tensor` dengan bentuk `(batch_size, point_batch_size, num_masks, height, width)`) -- Mask beresolusi rendah yang diprediksi. Ini adalah alias untuk `low_res_masks`. Mask ini perlu diproses lebih lanjut oleh processor agar ukurannya sesuai dengan ukuran gambar asli.
- **object_score_logits** (`torch.Tensor` dengan bentuk `(batch_size, point_batch_size, 1)`) -- Logits untuk skor objek, yang menunjukkan apakah objek hadir.
- **image_embeddings** (`tuple(torch.Tensor)`) -- Fitur dari FPN yang digunakan oleh mask decoder. Ini adalah tuple dari `torch.Tensor` di mana setiap tensor memiliki bentuk `(batch_size, channels, height, width)`.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari setiap tahap) dengan bentuk `(batch_size, height, width, hidden_size)`. Hidden-states dari model visi pada output dari setiap tahap.
- **vision_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari model visi.
- **mask_decoder_attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari mask decoder.

Contoh:

```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'>)
```

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

**Parameter:**

pixel_values (`torch.Tensor`) : Nilai piksel input dengan bentuk `(batch_size, num_channels, height, width)`.

**Mengembalikan:** `EdgeTamVisionEncoderOutput` atau `tuple(torch.Tensor)`

Sebuah `EdgeTamVisionEncoderOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([EdgeTamConfig](/docs/transformers/main/id/model_doc/edgetam#transformers.EdgeTamConfig)) dan input.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, height, width, hidden_size)`) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **fpn_hidden_states** (`tuple(torch.Tensor)`) -- Tuple dari `torch.Tensor` (satu untuk setiap level fitur, dari resolusi tinggi ke rendah) dengan bentuk `(batch_size, hidden_size, height, width)`. Peta fitur dari leher Feature Pyramid Network.
- **fpn_position_encoding** (`tuple(torch.Tensor)`) -- Tuple dari `torch.Tensor` (satu untuk setiap level fitur, dari resolusi tinggi ke rendah) dengan bentuk `(batch_size, hidden_size, height, width)`. Positional encoding yang sesuai dengan `fpn_hidden_states`.

Contoh:

```python
```