Hugging Face's logo

Transformers documentation

SegGPT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em HF papers em 2023-04-06 e contribuído para Hugging Face Transformers em 2024-02-26.

SegGPT

Visão geral

O modelo SegGPT foi proposto em SegGPT: Segmenting Everything In Context por Xinlong Wang, Xiaosong Zhang, Yue Cao, Wen Wang, Chunhua Shen e Tiejun Huang. O SegGPT utiliza um Transformer somente de decodificador que pode gerar uma máscara de segmentação a partir de uma imagem de entrada, uma imagem de prompt e sua máscara de prompt correspondente. O modelo alcança resultados notáveis em um único exemplo, com 56,1 mIoU no COCO-20 e 85,6 mIoU no FSS-1000.

O resumo do artigo é o seguinte:

Apresentamos o SegGPT, um modelo generalista para segmentar tudo em contexto. Unificamos diversas tarefas de segmentação em um framework generalista de aprendizado em contexto que acomoda diferentes tipos de dados de segmentação, transformando-os no mesmo formato de imagens. O treinamento do SegGPT é formulado como um problema de coloração em contexto, com mapeamento de cores aleatório para cada amostra de dados. O objetivo é realizar tarefas diversas de acordo com o contexto, em vez de depender de cores específicas. Após o treinamento, o SegGPT pode executar tarefas de segmentação arbitrárias em imagens ou vídeos por meio de inferência em contexto, como instância de objeto, stuff, parte, contorno e texto. O SegGPT é avaliado em uma ampla gama de tarefas, incluindo segmentação semântica few-shot, segmentação de objetos em vídeo, segmentação semântica e segmentação panótica. Nossos resultados mostram fortes capacidades em segmentar em domínio e fora de

Dicas:

  • É possível usar SegGptImageProcessor para preparar a entrada de imagem, o prompt e a máscara para o modelo.
  • É possível usar mapas de segmentação ou imagens RGB como máscaras de prompt. Se usar as imagens RGB, certifique-se de definir do_convert_rgb=False no método preprocess.
  • É altamente recomendável passar num_labels ao usar segmentation_maps (não considerando o fundo) durante o pré-processamento e o pós-processamento com SegGptImageProcessor para o seu caso de uso.
  • Ao realizar inferência com SegGptForImageSegmentation, se o seu batch_size for maior que 1, você pode usar ensemble de recursos entre as suas imagens passando feature_ensemble=True no método forward.

Aqui está como usar o modelo para segmentação semântica one-shot:

import torch
from datasets import load_dataset

from transformers import SegGptForImageSegmentation, SegGptImageProcessor


checkpoint = "BAAI/seggpt-vit-large"
image_processor = SegGptImageProcessor.from_pretrained(checkpoint)
model = SegGptForImageSegmentation.from_pretrained(checkpoint, device_map="auto")

dataset_id = "EduardoPacheco/FoodSeg103"
ds = load_dataset(dataset_id, split="train")
# Number of labels in FoodSeg103 (not including background)
num_labels = 103

image_input = ds[4]["image"]
ground_truth = ds[4]["label"]
image_prompt = ds[29]["image"]
mask_prompt = ds[29]["label"]

inputs = image_processor(
    images=image_input,
    prompt_images=image_prompt,
    segmentation_maps=mask_prompt,
    num_labels=num_labels,
    return_tensors="pt"
)

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

target_sizes = [image_input.size[::-1]]
mask = image_processor.post_process_semantic_segmentation(outputs, target_sizes, num_labels=num_labels)[0]

Este modelo foi contribuído por EduardoPacheco. O código original pode ser encontrado aqui.

SegGptConfig

classe transformers.SegGptConfig

< >

( 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 = 1024num_hidden_layers: int = 24num_attention_heads: int = 16hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.0initializer_range: float = 0.02layer_norm_eps: float = 1e-06image_size: int | list[int] | tuple[int, ...] = (896, 448)patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3qkv_bias: bool = Truemlp_dim: int | None = Nonedrop_path_rate: float | int = 0.1pretrain_image_size: int | list[int] | tuple[int, int] = 224decoder_hidden_size: int = 64use_relative_position_embeddings: bool = Truemerge_index: int = 2intermediate_hidden_state_indices: list[int] | tuple[int, ...] = (5, 11, 17, 23)beta: float = 0.01 )

Parâmetros

  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], opcional, padrão 0.0) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • layer_norm_eps (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização de camada.
  • image_size (Union[int, list[int], tuple[int, ...]], opcional, padrão (896, 448)) — O tamanho (resolução) de cada imagem.
  • patch_size (Union[int, list[int], tuple[int, int]], opcional, padrão 16) — O tamanho (resolução) de cada patch.
  • num_channels (int, opcional, padrão 3) — O número de canais de entrada.
  • qkv_bias (bool, opcional, padrão True) — Se deve adicionar um viés às queries, keys e values.
  • mlp_dim (int, opcional) — A dimensionalidade da camada MLP no codificador Transformer. Se não for definida, o valor padrão é hidden_size * 4.
  • drop_path_rate (Union[float, int], opcional, padrão 0.1) — Taxa de drop path para a fusão de patches.
  • pretrain_image_size (int, opcional, padrão 224) — O tamanho pré-treinado dos embeddings de posição absoluta.
  • decoder_hidden_size (int, opcional, padrão 64) — Dimensão das representações ocultas.
  • use_relative_position_embeddings (bool, opcional, padrão True) — Se deve usar embeddings de posição relativa nas camadas de atenção.
  • merge_index (int, opcional, padrão 2) — O índice da camada do codificador para mesclar os embeddings.
  • intermediate_hidden_state_indices (list[int], opcional, padrão [5, 11, 17, 23]) — Os índices das camadas do codificador que são armazenadas como recursos para o decodificador.
  • beta (float, opcional, padrão 0.01) — Fator de regularização para SegGptLoss (perda smooth-l1).

Esta é a classe de configuração para armazenar a configuração de um SegGptModel. Ela é usada para instanciar um modelo Seggpt 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 BAAI/seggpt-vit-large

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 SegGptConfig, SegGptModel

>>> # Initializing a SegGPT seggpt-vit-large style configuration
>>> configuration = SegGptConfig()

>>> # Initializing a model (with random weights) from the seggpt-vit-large style configuration
>>> model = SegGptModel(configuration)

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

SegGptImageProcessor

classe transformers.SegGptImageProcessor

< >

( **kwargs: *<class 'transformers.models.seggpt.image_processing_seggpt.SegGptImageProcessorKwargs'> )

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 448, 'width': 448}): Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional, padrão True) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.485, 0.456, 0.406]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.229, 0.224, 0.225]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • num_labels (int, kwargs, opcional) — Número de classes na tarefa de segmentação (excluindo o fundo). Se especificado, uma paleta será construída, assumindo que class_idx 0 é o fundo, para mapear a prompt mask de um mapa de segmentação simples para uma imagem RGB de 3 canais. Não especificar isso resultará na duplicação da prompt mask ao longo da dimensão de canal quando do_convert_rgb for True.

Constrói um processador de imagem SegGptImageProcessor.

pré-processamento

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneprompt_images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneprompt_masks: 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.seggpt.image_processing_seggpt.SegGptImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Parâmetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • prompt_images (ImageInput, opcional) — Imagens de prompt para pré-processamento. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255.
  • prompt_masks (ImageInput, opcional) — Máscaras de prompt para pré-processamento. Podem estar no formato de mapas de segmentação (sem canais) ou de imagens RGB. Se estiverem no formato de imagens RGB, do_convert_rgb deve ser definido como False. Se estiverem no formato de mapas de segmentação, é recomendável especificar num_labels para construir uma paleta que mapeie a máscara de prompt de um único canal para RGB de 3 canais. Se num_labels não for especificado, a máscara de prompt será duplicada ao longo da dimensão de canais.
  • do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • num_labels (int, kwargs, opcional) — Número de classes na tarefa de segmentação (excluindo o fundo). Se especificado, uma paleta será construída, assumindo que class_idx 0 é o fundo, para mapear a prompt mask de um mapa de segmentação simples para uma imagem RGB de 3 canais. Não especificar isso resultará na duplicação da prompt mask ao longo da dimensão de canal quando do_convert_rgb for True.

Retorna

~image_processing_base.BatchFeature

  • data (dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

post_process_semantic_segmentation

< >

( outputstarget_sizes: list[tuple[int, int]] | None = Nonenum_labels: int | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

Parâmetros

  • outputs (SegGptImageSegmentationOutput) — Saídas brutas do modelo.
  • target_sizes (list[tuple[int, int]], opcional) — Lista de comprimento batch_size, em que cada item corresponde ao tamanho final solicitado (height, width) de cada previsão. Se deixado como None, as previsões não serão redimensionadas.
  • num_labels (int, opcional) — Número de classes na tarefa de segmentação (excluindo o fundo). Se especificado, uma paleta será construída para mapear as máscaras de previsão dos valores RGB de volta para os índices de classe. Deve corresponder ao valor usado durante o pré-processamento.
  • return_segmentation_scores (bool, opcional, padrão False) — Indica se as pontuações de segmentação devem ser retornadas junto com o mapa de segmentação. Quando True, cada elemento da lista retornada é um SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma (height, width)) e segmentation_scores (forma (num_labels+1, height, width) de distâncias L2 ao quadrado negativas para cada cor da paleta, ou None quando num_labels não é fornecido).

Retorna

list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]

Quando return_segmentation_scores=False (padrão), uma lista de comprimento batch_size em que cada item é um mapa de segmentação de forma (height, width) com IDs de classe. Quando return_segmentation_scores=True, uma lista de SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma (height, width)) e segmentation_scores (forma (num_labels+1, height, width)). Em ambos os casos, (height, width) corresponde ao tamanho alvo (se target_sizes for especificado).

Converte a saída de SegGptImageSegmentationOutput em mapas de segmentação. Suporta apenas PyTorch.

SegGptImageProcessorPil

classe transformers.SegGptImageProcessorPil

< >

( **kwargs: *<class 'transformers.models.seggpt.image_processing_pil_seggpt.SegGptImageProcessorKwargs'> )

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 448, 'width': 448}): Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional, padrão True) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.485, 0.456, 0.406]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.229, 0.224, 0.225]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • num_labels (int, kwargs, opcional) — Número de classes na tarefa de segmentação (excluindo o fundo). Se especificado, uma paleta será construída, assumindo que class_idx 0 é o fundo, para mapear a prompt mask de um mapa de segmentação simples para uma imagem RGB de 3 canais. Não especificar isso resultará na duplicação da prompt mask ao longo da dimensão de canal quando do_convert_rgb for True.

Constrói um processador de imagem SegGptImageProcessor.

pré-processamento

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneprompt_images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneprompt_masks: 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.seggpt.image_processing_pil_seggpt.SegGptImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Parâmetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • prompt_images (ImageInput, opcional) — Imagens de prompt para pré-processamento. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255.
  • prompt_masks (ImageInput, opcional) — Máscaras de prompt para pré-processamento. Podem estar no formato de mapas de segmentação (sem canais) ou de imagens RGB. Se estiverem no formato de imagens RGB, do_convert_rgb deve ser definido como False. Se estiverem no formato de mapas de segmentação, é recomendável especificar num_labels para construir uma paleta que mapeie a máscara de prompt de um único canal para RGB de 3 canais. Se num_labels não for especificado, a máscara de prompt será duplicada ao longo da dimensão de canais.
  • do_convert_rgb (bool, kwargs, opcional) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • num_labels (int, kwargs, opcional) — Número de classes na tarefa de segmentação (excluindo o fundo). Se especificado, uma paleta será construída, assumindo que class_idx 0 é o fundo, para mapear a prompt mask de um mapa de segmentação simples para uma imagem RGB de 3 canais. Não especificar isso resultará na duplicação da prompt mask ao longo da dimensão de canal quando do_convert_rgb for True.

Retorna

~image_processing_base.BatchFeature

  • data (dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

post_process_semantic_segmentation

< >

( outputstarget_sizes: list[tuple[int, int]] | None = Nonenum_labels: int | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

Parâmetros

  • outputs (SegGptImageSegmentationOutput) — Saídas brutas do modelo.
  • target_sizes (list[tuple[int, int]], opcional) — Lista de comprimento batch_size, em que cada item corresponde ao tamanho final solicitado (height, width) de cada previsão. Se deixado como None, as previsões não serão redimensionadas.
  • num_labels (int, opcional) — Número de classes na tarefa de segmentação (excluindo o fundo). Se especificado, uma paleta será construída para mapear as máscaras de previsão dos valores RGB de volta para os índices de classe. Deve corresponder ao valor usado durante o pré-processamento.
  • return_segmentation_scores (bool, opcional, padrão False) — Indica se as pontuações de segmentação devem ser retornadas junto com o mapa de segmentação. Quando True, cada elemento da lista retornada é um SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma (height, width)) e segmentation_scores (forma (num_labels+1, height, width) de distâncias L2 ao quadrado negativas para cada cor da paleta, ou None quando num_labels não é fornecido).

Retorna

list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]

Quando return_segmentation_scores=False (padrão), uma lista de comprimento batch_size em que cada item é um mapa de segmentação de forma (height, width) com IDs de classe. Quando return_segmentation_scores=True, uma lista de SemanticSegmentationPostProcessorOutput com os campos segmentation (IDs de classe, forma (height, width)) e segmentation_scores (forma (num_labels+1, height, width)). Em ambos os casos, (height, width) corresponde ao tamanho alvo (se target_sizes for especificado).

Converte a saída de SegGptImageSegmentationOutput em mapas de segmentação. Suporta apenas PyTorch.

SegGptModel

classe transformers.SegGptModel

< >

( config: SegGptConfig )

Parâmetros

  • config (SegGptConfig) — 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 Seggpt puro, que gera os hidden-states brutos sem nenhum head específico 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

< >

( pixel_values: Tensorprompt_pixel_values: Tensorprompt_masks: Tensorbool_masked_pos: typing.Optional[torch.BoolTensor] = Nonefeature_ensemble: bool | None = Noneembedding_type: str | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SegGptEncoderOutput or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando SegGptImageProcessor. Consulte SegGptImageProcessor.call() para mais detalhes (processor_class usa SegGptImageProcessor para processar as imagens).
  • prompt_pixel_values (torch.Tensor de forma (batch_size, num_channels, height, width)) — Valores de pixels do prompt. Os valores de pixels do prompt podem ser obtidos usando AutoImageProcessor. Consulte SegGptImageProcessor.call() para mais detalhes.
  • prompt_masks (torch.Tensor de forma (batch_size, num_channels, height, width)) — Máscara de prompt. A máscara de prompt pode ser obtida usando AutoImageProcessor. Consulte SegGptImageProcessor.call() para mais detalhes.
  • bool_masked_pos (torch.BoolTensor de forma (batch_size, num_patches), opcional) — Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0).
  • feature_ensemble (bool, optional) — Boolean indicating whether to use feature ensemble or not. If True, the model will use feature ensemble if we have at least two prompts. If False, the model will not use feature ensemble. This argument should be considered when doing few-shot inference on an input image i.e. more than one prompt for the same image.
  • embedding_type (str, opcional) — Tipo de embedding. Indica se o prompt é um embedding semântico ou de instância. Pode ser instance ou semantic.
  • labels (torch.Tensor de forma (batch_size, num_channels, height, width), optional) — Máscara de verdade fundamental para as imagens de entrada.
  • output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
  • output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

SegGptEncoderOutput ou tuple(torch.Tensor)

Um SegGptEncoderOutput 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 (SegGptConfig) e das entradas.

O método forward do SegGptModel sobrescreve o método especial __call__.

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

  • last_hidden_state (torch.Tensor de forma (batch_size, patch_height, patch_width, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.
  • hidden_states (tuple[torch.Tensor], optional, retornado quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings + um para a saída de cada camada) de forma (batch_size, patch_height, patch_width, hidden_size).
  • attentions (tuple[torch.Tensor], optional, retornado quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, seq_len, seq_len).
  • intermediate_hidden_states (tuple[torch.Tensor], opcional, retornado quando config.intermediate_hidden_state_indices está definido) — Tupla de torch.Tensor com forma (batch_size, patch_height, patch_width, hidden_size). Cada elemento da Tupla corresponde à saída da camada especificada em config.intermediate_hidden_state_indices. Além disso, cada recurso passa por um LayerNorm.

Exemplos:

>>> from transformers import SegGptImageProcessor, SegGptModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> image_input_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_2.jpg"
>>> image_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1.jpg"
>>> mask_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1_target.png"

>>> with httpx.stream("GET", image_input_url) as response:
...     image_input = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", image_prompt_url) as response:
...     image_prompt = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", mask_prompt_url) as response:
...     mask_prompt = Image.open(BytesIO(response.read())).convert("L")

>>> checkpoint = "BAAI/seggpt-vit-large"
>>> model = SegGptModel.from_pretrained(checkpoint)
>>> image_processor = SegGptImageProcessor.from_pretrained(checkpoint)

>>> inputs = image_processor(images=image_input, prompt_images=image_prompt, prompt_masks=mask_prompt, return_tensors="pt")

>>> outputs = model(**inputs)
>>> list(outputs.last_hidden_state.shape)
[1, 56, 28, 1024]

SegGptForImageSegmentation

classe transformers.SegGptForImageSegmentation

< >

( config: SegGptConfig )

Parâmetros

  • config (SegGptConfig) — 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.

Modelo SegGpt com um decodificador no topo para segmentação de imagem em um único exemplo.

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

< >

( pixel_values: Tensorprompt_pixel_values: Tensorprompt_masks: Tensorbool_masked_pos: typing.Optional[torch.BoolTensor] = Nonefeature_ensemble: bool | None = Noneembedding_type: str | None = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SegGptImageSegmentationOutput or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando SegGptImageProcessor. Consulte SegGptImageProcessor.call() para mais detalhes (processor_class usa SegGptImageProcessor para processar as imagens).
  • prompt_pixel_values (torch.Tensor de forma (batch_size, num_channels, height, width)) — Valores de pixels do prompt. Os valores de pixels do prompt podem ser obtidos usando AutoImageProcessor. Consulte SegGptImageProcessor.call() para mais detalhes.
  • prompt_masks (torch.Tensor de forma (batch_size, num_channels, height, width)) — Máscara de prompt. A máscara de prompt pode ser obtida usando AutoImageProcessor. Consulte SegGptImageProcessor.call() para mais detalhes.
  • bool_masked_pos (torch.BoolTensor de forma (batch_size, num_patches), opcional) — Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0).
  • feature_ensemble (bool, optional) — Boolean indicating whether to use feature ensemble or not. If True, the model will use feature ensemble if we have at least two prompts. If False, the model will not use feature ensemble. This argument should be considered when doing few-shot inference on an input image i.e. more than one prompt for the same image.
  • embedding_type (str, opcional) — Tipo de embedding. Indica se o prompt é um embedding semântico ou de instância. Pode ser instance ou semantic.
  • labels (torch.Tensor of shape (batch_size, num_channels, height, width), optional) — Ground truth mask for input images.
  • output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
  • output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

SegGptImageSegmentationOutput ou tuple(torch.Tensor)

Uma SegGptImageSegmentationOutput 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 (SegGptConfig) e das entradas.

O método forward de SegGptForImageSegmentation substitui o método especial __call__.

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

  • loss (torch.Tensor, opcional, retornado quando labels é fornecido) — O valor da perda.
  • pred_masks (torch.Tensor de forma (batch_size, num_channels, height, width)) — As máscaras previstas.
  • hidden_states (tuple[torch.Tensor], optional, retornado quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings + um para a saída de cada camada) de forma (batch_size, patch_height, patch_width, hidden_size).
  • attentions (tuple[torch.Tensor], optional, retornado quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, seq_len, seq_len).

Exemplos:

>>> from transformers import SegGptImageProcessor, SegGptForImageSegmentation
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> image_input_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_2.jpg"
>>> image_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1.jpg"
>>> mask_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1_target.png"

>>> with httpx.stream("GET", image_input_url) as response:
...     image_input = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", image_prompt_url) as response:
...     image_prompt = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", mask_prompt_url) as response:
...     mask_prompt = Image.open(BytesIO(response.read())).convert("L")

>>> checkpoint = "BAAI/seggpt-vit-large"
>>> model = SegGptForImageSegmentation.from_pretrained(checkpoint)
>>> image_processor = SegGptImageProcessor.from_pretrained(checkpoint)

>>> inputs = image_processor(images=image_input, prompt_images=image_prompt, prompt_masks=mask_prompt, return_tensors="pt")
>>> outputs = model(**inputs)
>>> result = image_processor.post_process_semantic_segmentation(outputs, target_sizes=[(image_input.height, image_input.width)])[0]
>>> print(list(result.shape))
[170, 297]
Update on GitHub

←SegFormer Segment Anything→