Transformers documentation
EdgeTAM
Este modelo foi publicado no HF papers em 13/01/2025 e contribuído para o Hugging Face Transformers em 29/09/2025.
EdgeTAM
Visão geral
O modelo EdgeTAM foi proposto em EdgeTAM: On-Device Track Anything Model 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. O código original pode ser encontrado aqui.
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:
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
39Segmentação Básica de Imagens
Clique em um único ponto
Você pode segmentar objetos fornecendo um único clique no objeto que deseja segmentar:
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:
# 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:
# 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:
# 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:
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:
# 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:
# 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:
# 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:
# 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
classe transformers.EdgeTamConfig
< 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 )
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 usado para inicializar EdgeTamPromptEncoderConfig. - mask_decoder_config (Union[
dict,EdgeTamMaskDecoderConfig], opcional) — Dicionário de opções de configuração usado para inicializar EdgeTamMaskDecoderConfig. - initializer_range (
float, opcional, padrão0.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
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> 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
classe transformers.EdgeTamVisionConfig
< 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 )
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 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 top-down do FPN. - 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ãogelu) — 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ão1e-06) — O epsilon usado pelas camadas de normalização de camada. - initializer_range (
float, opcional, padrão0.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
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
EdgeTamMaskDecoderConfig
classe transformers.EdgeTamMaskDecoderConfig
< 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 )
Parâmetros
- hidden_size (
int, opcional, padrão256) — Dimensão das representações ocultas. - hidden_act (
str, opcional, padrãogelu) — 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 de duas vias. - num_hidden_layers (
int, opcional, padrão2) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão8) — 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ãoTrue) — Se deve usar dynamic multimask via stability. - 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 multimask 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
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
EdgeTamPromptEncoderConfig
classe transformers.EdgeTamPromptEncoderConfig
< 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 )
Parâmetros
- hidden_size (
int, opcional, padrão256) — Dimensão das representações ocultas. - image_size (
Union[int, list[int], tuple[int, int]], opcional, padrão1024) — O tamanho (resolução) de cada imagem. - patch_size (
Union[int, list[int], tuple[int, int]], opcional, padrão16) — O tamanho (resolução) de cada patch. - mask_input_channels (
int, opcional, padrão 16) — O número de canais a serem fornecidos ao móduloMaskDecoder. - num_point_embeddings (
int, opcional, padrão 4) — O número de incorporações de pontos a serem usadas. - hidden_act (
str, opcional, padrãogelu) — 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ão1e-06) — O epsilon usado pelas camadas de normalização de camada. - scale (
float, opcional, padrão 1) — 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
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
EdgeTamVisionModel
classe transformers.EdgeTamVisionModel
< source >( config: EdgeTamVisionConfig )
Parâmetros
- config (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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )
EdgeTamModel
classe transformers.EdgeTamModel
< source >( config: EdgeTamConfig )
Parâmetros
- config (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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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'> ) → EdgeTamImageSegmentationOutput or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde 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. Consulte Sam2ImageProcessor.call() para detalhes (Sam2Processor usa Sam2ImageProcessor para processar imagens). - input_points (
torch.Tensorde 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 tensorestorchde 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 desejamos 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.LongTensorde 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ótulos1: o ponto é um ponto que contém o objeto de interesse0: o ponto é um ponto que 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, portanto deve ser ignorado pelo codificador de prompt
Os rótulos de preenchimento devem ser feitos automaticamente pelo processador.
- input_boxes (
torch.Tensorde forma(batch_size, num_boxes, 4)) — Caixas de entrada para os pontos, usadas pelo prompt encoder para codificar o prompt. Geralmente, isso resulta em máscaras geradas muito melhores. As caixas podem ser obtidas passando uma lista de listas de listas para o processor, que gerará umtorchtensor, em que cada dimensão corresponde, 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 entraday1: a coordenada y do ponto superior esquerdo da caixa de entradax2: a coordenada x do ponto inferior direito da caixa de entraday2: a coordenada y do ponto inferior direito da caixa de entrada
- input_masks (
torch.Tensorde 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.Tensorde forma(batch_size, output_channels, window_size, window_size)) — Incorporações de imagem, usadas 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 as incorporações de imagem usando o métodoget_image_embeddingse, em seguida, fornecê-las ao métodoforwardem vez de fornecer ospixel_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”, especificandomultimask_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. - target_embedding (
torch.Tensor, opcional) — Embedding do conceito alvo, a ser fornecido ao decodificador de máscara para prompting semântico do alvo, caso o modelo seja usado para personalização, conforme introduzido em PerSAM.
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) e das entradas.
O método forward do 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
Moduleem 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.Tensorde 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.Tensorde forma(batch_size, point_batch_size, num_masks, height, width)) — As máscaras de baixa resolução previstas. Este é um alias paralow_res_masks. Essas máscaras precisam ser pós-processadas pelo processor para serem trazidas ao tamanho original da imagem. - object_score_logits (
torch.Tensorde 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 detorch.Tensorem que cada tensor tem a forma(batch_size, channels, height, width). - vision_hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=True) — Tupla detorch.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 quandooutput_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção do decodificador de máscara.
Exemplo:
>>> 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
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → EdgeTamVisionEncoderOutput or tuple(torch.Tensor)
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) e das entradas.
last_hidden_state (
torch.Tensorde forma(batch_size, height, width, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, 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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
fpn_hidden_states (
tuple(torch.Tensor)) — Tupla detorch.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 detorch.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 àsfpn_hidden_states.