Transformers documentation
SAM2
Model ini disumbangkan ke Hugging Face Transformers pada 2025-08-14.
SAM2
Ikhtisar
SAM2 (Segment Anything Model 2) diusulkan dalam Segment Anything in Images and Videos oleh Nikhila Ravi, Valentin Gabeur, Yuan-Ting Hu, Ronghang Hu, Chaitanya Ryali, Tengyu Ma, Haitham Khedr, Roman Rädle, Chloe Rolland, Laura Gustafson, Eric Mintun, Junting Pan, Kalyan Vasudev Alwala, Nicolas Carion, Chao-Yuan Wu, Ross Girshick, Piotr Dollár, Christoph Feichtenhofer.
Model ini dapat digunakan untuk memprediksi mask segmentasi dari objek apa pun yang menjadi perhatian, dengan diberikan gambar atau video sebagai input, serta titik atau kotak batas sebagai input.
Abstrak dari makalah tersebut adalah sebagai berikut:
Kami memperkenalkan Segment Anything Model 2 (SAM 2), sebuah model fondasi untuk menyelesaikan pemisahan visual yang dapat dipromptkan pada gambar dan video. Kami membangun mesin data, yang meningkatkan model dan data melalui interaksi pengguna, untuk mengumpulkan dataset pemisahan video terbesar hingga saat ini. Model kami adalah arsitektur transformer sederhana dengan memori streaming untuk pemrosesan video real-time. SAM 2 yang dilatih pada data kami memberikan kinerja yang kuat di berbagai tugas. Dalam pemisahan video, kami mengamati akurasi yang lebih baik, menggunakan 3x lebih sedikit interaksi dibandingkan pendekatan sebelumnya. Dalam pemisahan gambar, model kami lebih akurat dan 6x lebih cepat daripada Segment Anything Model (SAM). Kami percaya bahwa data, model, dan wawasan kami akan menjadi tonggak penting untuk pemisahan video dan tugas persepsi terkait. Kami merilis versi model kami, dataset, dan demo interaktif.
Tips:
- Dukungan Batch & Video: SAM2 secara native mendukung pemrosesan batch dan segmentasi video yang mulus, sedangkan SAM asli dirancang untuk gambar statis dan alur kerja yang lebih sederhana, yaitu satu gambar pada satu waktu.
- Akurasi & Generalisasi: SAM2 menunjukkan kualitas segmentasi, ketangguhan, dan generalisasi zero-shot ke domain baru yang lebih baik dibandingkan SAM asli, terutama dengan prompt campuran.
Model ini disumbangkan oleh sangbumchoi dan yonigozlan. Kode aslinya dapat ditemukan di sini.
Contoh penggunaan
Generasi Mask Otomatis dengan Pipeline
SAM2 dapat digunakan untuk pembuatan maska otomatis guna memsegmentasi semua objek dalam gambar menggunakan pipeline mask-generation:
from transformers import pipeline
generator = pipeline("mask-generation", model="facebook/sam2.1-hiera-large", 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
39Segmentasi Gambar Dasar
Klik Titik Tunggal
Anda dapat memsegmentasi objek dengan memberikan satu kali klik pada objek yang ingin Anda segmentasi:
from transformers import Sam2Processor, Sam2Model
import torch
from PIL import Image
import requests
model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", device_map="auto")
processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large")
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, 1500, 2250)Beberapa Poin untuk Penyempurnaan
Anda dapat memberikan beberapa titik untuk menyempurnakan segmentasi:
# 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]Input Kotak Batas
SAM2 juga mendukung input kotak batas (bounding box) untuk segmentasi:
# 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]Segmentasi Objek Ganda
Anda dapat memsegmentasikan beberapa objek secara bersamaan:
# 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 objectsInferensi Batch
Gambar Berbatch
Proses beberapa gambar secara bersamaan untuk efisiensi yang lebih baik:
from transformers import Sam2Processor, Sam2Model
import torch
from PIL import Image
import requests
model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", device_map="auto")
processor = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large")
# 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 objectsObjek Batch per Gambar
Segmentasikan beberapa objek di dalam setiap gambar menggunakan inferensi batch:
# 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:
# 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:
# 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 respectivelyMenggunakan Masker Sebelumnya sebagai Input
SAM2 dapat menggunakan mask dari prediksi sebelumnya sebagai input untuk menyempurnakan segmentasi:
# 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,
)Sam2Config
kelas transformers.Sam2Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprompt_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonemask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_range: float = 0.02 )
Parameter
- vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Objek config atau dictionary dari vision backbone. - prompt_encoder_config (Union[
dict,Sam2PromptEncoderConfig], opsional) — Kamus opsi konfigurasi yang digunakan untuk menginisialisasi Sam2PromptEncoderConfig. - mask_decoder_config (Union[
dict,Sam2MaskDecoderConfig], opsional) — Kamus opsi konfigurasi yang digunakan untuk menginisialisasi Sam2MaskDecoderConfig. - initializer_range (
float, opsional, defaultnya0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam2Model. Kelas ini digunakan untuk membuat instans model Sam2 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2.1-hiera-tiny
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Contoh:
>>> from transformers import (
... Sam2VisionConfig,
... Sam2PromptEncoderConfig,
... Sam2MaskDecoderConfig,
... Sam2Model,
... )
>>> # Initializing a Sam2Config with `"facebook/sam2.1_hiera_tiny"` style configuration
>>> configuration = Sam2Config()
>>> # Initializing a Sam2Model (with random weights) from the `"facebook/sam2.1_hiera_tiny"` style configuration
>>> model = Sam2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a Sam2Config from a Sam2VisionConfig, Sam2PromptEncoderConfig, and Sam2MaskDecoderConfig
>>> # Initializing SAM2 vision encoder, memory attention, and memory encoder configurations
>>> vision_config = Sam2VisionConfig()
>>> prompt_encoder_config = Sam2PromptEncoderConfig()
>>> mask_decoder_config = Sam2MaskDecoderConfig()
>>> config = Sam2Config(vision_config, prompt_encoder_config, mask_decoder_config)Sam2HieraDetConfig
kelas transformers.Sam2HieraDetConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 96num_attention_heads: int = 1num_channels: int = 3image_size: int | list[int] | None = Nonepatch_kernel_size: int | list[int] | None = Nonepatch_stride: int | list[int] | None = Nonepatch_padding: int | list[int] | None = Nonequery_stride: int | list[int] | None = Nonewindow_positional_embedding_background_size: list[int] | None = Nonenum_query_pool_stages: int = 3blocks_per_stage: list[int] | None = Noneembed_dim_per_stage: list[int] | None = Nonenum_attention_heads_per_stage: list[int] | None = Nonewindow_size_per_stage: list[int] | None = Noneglobal_attention_blocks: list[int] | None = Nonemlp_ratio: float = 4.0hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06initializer_range: float = 0.02 )
Parameter
- hidden_size (
int, opsional, default96) — Dimensi dari representasi tersembunyi. - num_attention_heads (
int, opsional, default1) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer. - num_channels (
int, opsional, defaultnya3) — Jumlah saluran input. - image_size (
Union[int, list[int]], opsional) — Ukuran (resolusi) dari setiap gambar. - patch_kernel_size (
list[int], opsional, default[7, 7]) — Ukuran kernel dari patch. - patch_stride (
list[int], opsional, default[4, 4]) — Stride dari patch. - patch_padding (
list[int], opsional, default[3, 3]) — Padding dari patch. - query_stride (
list[int], opsional, default[2, 2]) — Stride downsampling antar tahap. - window_positional_embedding_background_size (
list[int], opsional, default[7, 7]) — Ukuran jendela per tahap ketika tidak menggunakan global attention. - num_query_pool_stages (
int, opsional, default 3) — Jumlah tahap query pool. - blocks_per_stage (
list[int], opsional, default[1, 2, 7, 2]) — Jumlah blok per tahap. - embed_dim_per_stage (
list[int], opsional, default[96, 192, 384, 768]) — Dimensi embedding per tahap. - num_attention_heads_per_stage (
list[int], opsional, default[1, 2, 4, 8]) — Jumlah attention heads per stage. - window_size_per_stage (
list[int], opsional, default[8, 4, 14, 7]) — Ukuran jendela per tahap. - global_attention_blocks (
list[int], opsional, default[5, 7, 9]) — Blok-blok tempat global attention digunakan. - mlp_ratio (
float, opsional, default4.0) — Rasio dimensi tersembunyi MLP terhadap dimensi embedding. - hidden_act (
str, opsional, defaultnyagelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - layer_norm_eps (
float, opsional, defaultnya1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan. - initializer_range (
float, opsional, defaultnya0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam2Model. Kelas ini digunakan untuk membuat instans model Sam2 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2.1-hiera-tiny
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Sam2VisionConfig
kelas transformers.Sam2VisionConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonebackbone_channel_list: list[int] | None = Nonebackbone_feature_sizes: list | None = Nonefpn_hidden_size: int = 256fpn_kernel_size: int = 1fpn_stride: int = 1fpn_padding: int = 0fpn_top_down_levels: list[int] | None = Nonenum_feature_levels: int = 3hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06initializer_range: float = 0.02 )
Parameter
- backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opsional) — Konfigurasi dari model backbone. - backbone_channel_list (
List[int], opsional, default[768, 384, 192, 96]) — Daftar dimensi channel untuk backbone. - backbone_feature_sizes (
List[List[int]], opsional, default[[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, default 1) — Ukuran kernel untuk konvolusi di neck. - fpn_stride (
int, opsional, default 1) — Stride untuk konvolusi di neck. - fpn_padding (
int, opsional, default 0) — Padding untuk konvolusi di neck. - fpn_top_down_levels (
List[int], opsional, default[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, defaultnyagelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - layer_norm_eps (
float, opsional, defaultnya1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan. - initializer_range (
float, opsional, defaultnya0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam2Model. Kelas ini digunakan untuk membuat instans model Sam2 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2.1-hiera-tiny
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Sam2MaskDecoderConfig
kelas transformers.Sam2MaskDecoderConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256hidden_act: str = 'gelu'mlp_dim: int = 2048num_hidden_layers: int = 2num_attention_heads: int = 8attention_downsample_rate: int = 2num_multimask_outputs: int = 3iou_head_depth: int = 3iou_head_hidden_dim: int = 256dynamic_multimask_via_stability: bool = Truedynamic_multimask_stability_delta: float = 0.05dynamic_multimask_stability_thresh: float = 0.98 )
Parameter
- hidden_size (
int, opsional, default256) — Dimensi dari representasi tersembunyi. - hidden_act (
str, opsional, defaultnyagelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - mlp_dim (
int, opsional, default 2048) — Dimensi dari MLP dalam transformer dua arah. - num_hidden_layers (
int, opsional, default2) — Jumlah lapisan tersembunyi dalam decoder Transformer. - num_attention_heads (
int, opsional, default8) — Jumlah attention heads untuk setiap lapisan attention di decoder Transformer. - attention_downsample_rate (
int, opsional, default 2) — Rasio downsample untuk lapisan attention. - num_multimask_outputs (
int, opsional, defaultnya 3) — Jumlah output multimask. - iou_head_depth (
int, opsional, defaultnya 3) — Kedalaman dari IoU head. - iou_head_hidden_dim (
int, opsional, default 256) — Dimensi tersembunyi dari kepala IoU. - dynamic_multimask_via_stability (
bool, opsional, defaultnyaTrue) — Apakah akan menggunakan dynamic multimask via stability. - dynamic_multimask_stability_delta (
float, opsional, default 0.05) — Delta stabilitas untuk dynamic multimask. - dynamic_multimask_stability_thresh (
float, opsional, default 0.98) — Ambang batas stabilitas untuk dynamic multimask.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Sam2Model. Kelas ini digunakan untuk membuat instans model Sam2 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2.1-hiera-tiny
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Sam2PromptEncoderConfig
kelas transformers.Sam2PromptEncoderConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16mask_input_channels: int = 16num_point_embeddings: int = 4hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06scale: int = 1 )
Parameter
- hidden_size (
int, opsional, default256) — Dimensi dari representasi tersembunyi. - image_size (
Union[int, list[int], tuple[int, int]], opsional, defaultnya1024) — Ukuran (resolusi) dari setiap gambar. - patch_size (
Union[int, list[int], tuple[int, int]], opsional, defaultnya16) — Ukuran (resolusi) dari setiap patch. - mask_input_channels (
int, opsional, default 16) — Jumlah channel yang akan diberikan ke modulMaskDecoder. - num_point_embeddings (
int, opsional, defaultnya 4) — Jumlah point embeddings yang akan digunakan. - hidden_act (
str, opsional, defaultnyagelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya,"gelu","relu","silu", dan sebagainya. - layer_norm_eps (
float, opsional, defaultnya1e-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 Sam2Model. Kelas ini digunakan untuk membuat instans model Sam2 berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari facebook/sam2.1-hiera-tiny
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Sam2Processor
kelas transformers.Sam2Processor
< source >( image_processortarget_size: int | None = Nonepoint_pad_value: int = -10**kwargs )
Parameter
- image_processor (
Sam2ImageProcessor) — Image processor adalah input yang wajib diisi. - target_size (
int, opsional) — Ukuran target (dalam piksel) untuk menormalisasi titik input dan kotak batas. Jika tidak disediakan, secara default menggunakan konfigurasi ukuran dari image processor. Semua koordinat input (titik dan kotak) dinormalisasi ke ukuran ini sebelum diteruskan ke model. Hal ini memastikan representasi koordinat yang konsisten terlepas dari dimensi gambar asli. - point_pad_value (
int, opsional, default -10) — Nilai yang digunakan untuk mengisi titik input saat melakukan batching pada sekuens dengan panjang berbeda. Nilai ini digunakan untuk menandai posisi yang di-*pad* dan dipertahankan selama normalisasi koordinat.
Membangun Sam2Processor yang membungkus image processor menjadi satu processor tunggal.
Sam2Processor menyediakan semua fungsionalitas dari Sam2ImageProcessor. Lihat ~Sam2ImageProcessor untuk informasi lebih lanjut.
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonesegmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneinput_points: typing.Union[list[list[list[list[float]]]], torch.Tensor, NoneType] = Noneinput_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = Noneinput_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = Noneoriginal_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs ) → A BatchEncoding with the following fields
Parameter
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opsional) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, aturdo_rescale=False. - segmentation_maps (
ImageInput, opsional) — Peta segmentasi yang akan diproses. - input_points (
list[list[list[list[float]]]],torch.Tensor, opsional) — Titik-titik yang akan ditambahkan ke frame. - input_labels (
list[list[list[int]]],torch.Tensor, opsional) — Label untuk titik-titik tersebut. - input_boxes (
list[list[list[float]]],torch.Tensor, opsional) — Kotak pembatas (bounding boxes) yang akan ditambahkan ke bingkai. - original_sizes (
list[list[float]],torch.Tensor, opsional) — Ukuran asli dari gambar-gambar tersebut. - return_tensors (
Union[str, ~utils.generic.TensorType], opsional) — Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:'pt': Mengembalikan objek PyTorchtorch.Tensor.'np': Mengembalikan objek NumPynp.ndarray.
Mengembalikan
BatchEncoding dengan field-field berikut
pixel_values(torch.Tensor): Gambar yang telah diproses.original_sizes(list[list[float]]): Ukuran asli dari gambar-gambar tersebut.labels(torch.Tensor): Peta segmentasi yang telah diproses (jika disediakan).input_points(torch.Tensor): Titik-titik yang telah diproses.input_labels(torch.Tensor): Label yang telah diproses.input_boxes(torch.Tensor): Kotak pembatas yang telah diproses.
post_process_masks
< source >( masksoriginal_sizesmask_threshold = 0.0binarize = Truemax_hole_area = 0.0max_sprinkle_area = 0.0apply_non_overlapping_constraints = False**kwargs ) → (torch.Tensor)
Parameter
- masks (
Union[List[torch.Tensor], List[np.ndarray]]) — Mask yang di-batch dari mask_decoder dalam format (batch_size, num_channels, height, width). - original_sizes (
Union[torch.Tensor, List[Tuple[int,int]]]) — Ukuran asli setiap gambar sebelum di-resize ke bentuk input yang diharapkan model, dalam format (tinggi, lebar). - mask_threshold (
float, opsional, default 0.0) — Ambang batas untuk operasi binarisasi dan pascaproses. - binarize (
bool, opsional, defaultTrue) — Apakah akan membinerisasi mask. - max_hole_area (
float, opsional, default 0.0) — Luas maksimum lubang yang akan diisi. - max_sprinkle_area (
float, opsional, default 0.0) — Area maksimum sprinkle yang akan diisi. - apply_non_overlapping_constraints (
bool, opsional, defaultFalse) — Apakah akan menerapkan kendala non-overlapping pada mask.
Mengembalikan
(torch.Tensor)
Mask yang di-batch dalam format batch_size, num_channels, height, width, di mana (height, width) ditentukan oleh original_size.
Hapus padding dan upscale mask ke ukuran gambar asli.
Sam2ImageProcessor
kelas transformers.Sam2ImageProcessor
< source >( **kwargs: *<class 'transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs'> )
Parameter
- do_convert_rgb (
bool, kwargs, opsional, defaultTrue) — Apakah akan mengkonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional, defaultTrue) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultnya{'height' -- 1024, 'width': 1024}): Menggambarkan dimensi input maksimum ke model. - default_to_square (
bool, kwargs, opsional, defaultnyaTrue) — Apakah akan menggunakan gambar persegi sebagai default saat melakukan resize, jika size berupa int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, defaultnya2) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional, defaultTrue) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional, default0.00392156862745098) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional, defaultTrue) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.485, 0.456, 0.406]) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional, defaultnya[0.229, 0.224, 0.225]) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional, defaultNone) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, defaultNone) — Ukuran dalam{"height": int, "width" int}untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jikapad_sizetidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:"channels_first"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.NONE: gambar dalam format (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke'pt', selain itu mengembalikan daftar tensor. - disable_grouping (
bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang. - mask_size (
dict[str, *kwargs*, int], opsional) — Ukuran{"height": int, "width": int}untuk mengubah ukuran peta segmentasi.
Membangun pemroses gambar Sam2ImageProcessor.
praproses
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.models.sam2.image_processing_sam2.Sam2ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature
Parameter
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, aturdo_rescale=False. - segmentation_maps (
ImageInput, opsional) — Peta segmentasi yang akan dipreproses. - do_convert_rgb (
bool, kwargs, opsional) — Apakah akan mengonversi gambar ke RGB. - do_resize (
bool, kwargs, opsional) — Apakah akan mengubah ukuran gambar. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Menggambarkan dimensi input maksimum untuk model. - default_to_square (
bool, kwargs, opsional) — Apakah akan menggunakan gambar persegi sebagai default saat mengubah ukuran, jika size berupa int. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran gambar keluaran setelah menerapkancenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filter resampling yang digunakan jika mengubah ukuran gambar. Ini dapat berupa salah satu enumPILImageResampling. Hanya berpengaruh jikado_resizediatur keTrue. - do_rescale (
bool, kwargs, opsional) — Apakah akan melakukan penskalaan ulang pada gambar. - rescale_factor (
float, kwargs, opsional) — Faktor rescale untuk menskalakan ulang gambar jikado_rescalediatur keTrue. - do_normalize (
bool, kwargs, opsional) — Apakah akan menormalisasi gambar. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opsional) — Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jikado_normalizediatur keTrue. - do_pad (
bool, kwargs, opsional) — Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. - pad_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Ukuran dalam{"height": int, "width" int}untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang disediakan untuk pra-pemrosesan. Jikapad_sizetidak disediakan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketikado_pad=True. - do_center_crop (
bool, kwargs, opsional) — Apakah akan melakukan center crop pada gambar. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — HanyaChannelDimension.FIRSTyang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opsional) — Format dimensi channel untuk gambar input. Jika tidak diset, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari:"channels_first"atauChannelDimension.FIRST: gambar dalam format (num_channels, height, width)."channels_last"atauChannelDimension.LAST: gambar dalam format (height, width, num_channels)."none"atauChannelDimension.NONE: gambar dalam format (height, width).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Mengembalikan tensor bertumpuk jika diset ke'pt', selain itu mengembalikan daftar tensor. - disable_grouping (
bool, kwargs, opsional) — Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan bukan dalam batch. Jika None, akan diatur ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 - image_seq_length (
int, kwargs, opsional) — Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini seharusnya diatur sebagai atribut prosesor pada model-model mendatang. - mask_size (
dict[str, *kwargs*, int], opsional) — Ukuran{"height": int, "width": int}untuk mengubah ukuran peta segmentasi.
Mengembalikan
~image_processing_base.BatchFeature
- data (
dict) — Kamus berisi daftar/array/tensor yang dikembalikan oleh metode call (‘pixel_values’, dll.). - tensor_type (
Union[None, str, TensorType], opsional) — Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.
Sam2HieraDetModel
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )
Sam2VisionModel
kelas transformers.Sam2VisionModel
< source >( config: Sam2VisionConfig )
Parameter
- config (Sam2VisionConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Model visual dari Sam tanpa head atau proyeksi di atasnya.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari 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
< source >( pixel_values: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )
Sam2Model
kelas transformers.Sam2Model
< source >( config: Sam2Config )
Parameter
- config (Sam2Config) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.
Segment Anything Model 2 (SAM 2) untuk menghasilkan mask segmentasi, berdasarkan gambar input dan titik serta label, kotak, atau mask input.
Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari 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
< source >( pixel_values: typing.Optional[torch.Tensor] = Noneinput_points: typing.Optional[torch.Tensor] = Noneinput_labels: typing.Optional[torch.LongTensor] = Noneinput_boxes: typing.Optional[torch.Tensor] = Noneinput_masks: typing.Optional[torch.LongTensor] = Noneimage_embeddings: typing.Optional[torch.Tensor] = Nonemultimask_output: bool = Trueattention_similarity: typing.Optional[torch.Tensor] = Nonetarget_embedding: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sam2ImageSegmentationOutput or tuple(torch.Tensor)
Parameter
- pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size), opsional) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan Sam2ImageProcessor. Lihat Sam2ImageProcessor.call() untuk detailnya (Sam2Processor menggunakan Sam2ImageProcessor untuk memproses gambar). - input_points (
torch.Tensordengan bentuk(batch_size, num_points, 2)) — Titik spasial 2D sebagai input, yang digunakan oleh prompt encoder untuk mengkodekan prompt. Umumnya menghasilkan hasil yang jauh lebih baik. Titik-titik ini dapat diperoleh dengan meneruskan daftar dari daftar dari daftar ke processor yang akan membuat tensortorchyang sesuai dengan dimensi 4. Dimensi pertama adalah ukuran batch gambar, dimensi kedua adalah ukuran batch titik (yaitu berapa banyak mask segmentasi yang ingin diprediksi model per titik input), dimensi ketiga adalah jumlah titik per mask segmentasi (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 berbeda diteruskan baik untuk setiap gambar, maupun 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.LongTensordengan 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 label1: titik tersebut adalah titik yang berisi objek yang diminati0: 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.Tensordengan bentuk(batch_size, num_boxes, 4)) — kotak input untuk titik-titik, yang digunakan oleh prompt encoder untuk meng-encode prompt. Umumnya menghasilkan mask yang jauh lebih baik. Kotak-kotak ini dapat diperoleh dengan meneruskan list of list of list ke processor, yang akan menghasilkantorchtensor, dengan setiap dimensi yang masing-masing sesuai dengan ukuran batch gambar, jumlah kotak per gambar, dan koordinat titik kiri atas dan kanan bawah kotak. Dalam urutan (x1,y1,x2,y2):x1: koordinat x dari titik kiri atas kotak inputy1: koordinat y dari titik kiri atas kotak inputx2: koordinat x dari titik kanan bawah kotak inputy2: koordinat y dari titik kanan bawah kotak input
- input_masks (
torch.Tensordengan 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.Tensordengan 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 metodeget_image_embeddings, lalu memasukkannya ke metodeforwardalih-alih memasukanpixel_values. - multimask_output (
bool, opsional) — Pada implementasi dan paper aslinya, model selalu menghasilkan 3 mask per gambar (atau per titik / per bounding box jika relevan). Namun, dimungkinkan untuk hanya menghasilkan satu mask, yang sesuai dengan mask “terbaik”, dengan menentukanmultimask_output=False. - attention_similarity (
torch.Tensor, opsional) — Tensor kesamaan perhatian, yang akan diberikan ke decoder mask untuk perhatian yang dipandu target dalam kasus model digunakan untuk personalisasi sebagaimana diperkenalkan dalam PerSAM. - target_embedding (
torch.Tensor, opsional) — Embedding dari konsep target, yang harus diberikan ke mask decoder untuk target-semantic prompting dalam kasus model digunakan untuk personalisasi sebagaimana diperkenalkan dalam PerSAM.
Mengembalikan
Sam2ImageSegmentationOutput atau tuple(torch.Tensor)
Sam2ImageSegmentationOutput atau tuple dari
torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sam2Config) dan input.
Metode forward dari Sam2Model menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya 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.Tensordengan bentuk(batch_size, point_batch_size, num_masks)) — Skor Intersection over Union (IoU) dari mask yang diprediksi. - pred_masks (
torch.Tensordengan bentuk(batch_size, point_batch_size, num_masks, height, width)) — Mask beresolusi rendah yang diprediksi. Ini adalah alias untuklow_res_masks. Mask ini perlu diproses lebih lanjut oleh processor agar ukurannya sesuai dengan ukuran gambar asli. - object_score_logits (
torch.Tensordengan 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 daritorch.Tensordi mana setiap tensor memiliki bentuk(batch_size, channels, height, width). - vision_hidden_states (
tuple(torch.Tensor), opsional, dikembalikan saatoutput_hidden_states=True) — Tuple daritorch.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 saatoutput_attentions=True) — Tuple daritorch.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 saatoutput_attentions=True) — Tuple daritorch.Tensor(satu untuk setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length). Bobot perhatian dari mask decoder.
Contoh:
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor
>>> model = AutoModel.from_pretrained("danelcsb/sam2.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/sam2.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
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sam2VisionEncoderOutput or tuple(torch.Tensor)
Parameter
- pixel_values (
torch.Tensor) — Nilai piksel input dengan bentuk(batch_size, num_channels, height, width).
Mengembalikan
Sam2VisionEncoderOutput atau tuple(torch.Tensor)
Sam2VisionEncoderOutput atau tuple dari
torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (Sam2Config) dan input.
last_hidden_state (
torch.Tensordengan bentuk(batch_size, height, width, hidden_size)) — Urutan hidden-states pada output dari lapisan terakhir model.pooler_output (
torch.Tensordengan 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 saatoutput_hidden_states=Truedilewatkan atau saatconfig.output_hidden_states=True) — Tuple daritorch.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 saatoutput_attentions=Truedilewatkan atau saatconfig.output_attentions=True) — Tuple daritorch.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 perhatian diri (self-attention).
fpn_hidden_states (
tuple(torch.Tensor)) — Tuple daritorch.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 daritorch.Tensor(satu untuk setiap level fitur, dari resolusi tinggi ke rendah) dengan bentuk(batch_size, hidden_size, height, width). Encoding posisi yang sesuai denganfpn_hidden_states.