Transformers documentation
OmDet-Turbo
Este modelo foi publicado em papers do HF em 2024-03-11 e contribuído para o Hugging Face Transformers em 2024-09-25.
OmDet-Turbo
Visão geral
O modelo OmDet-Turbo foi proposto em Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head por Tiancheng Zhao, Peng Liu, Xuan He, Lu Zhang, Kyusong Lee. O OmDet-Turbo incorpora componentes do RT-DETR e introduz um módulo de fusão multimodal ágil para alcançar capacidades de detecção de objetos em vocabulário aberto em tempo real, mantendo alta precisão. O modelo base atinge desempenho de até 100,2 FPS e 53,4 AP no COCO zero-shot.
O resumo do artigo é o seguinte:
Detectores baseados em transformers de ponta a ponta (DETRs) demonstraram desempenho excepcional em tarefas de detecção de objetos em conjunto fechado e de vocabulário aberto (OVD) por meio da integração de modalidades de linguagem. No entanto, seus requisitos computacionais exigentes têm impedido sua aplicação prática em cenários de detecção de objetos em tempo real (OD). Neste artigo, analisamos as limitações de dois modelos de destaque no benchmark OVDEval, OmDet e Grounding-DINO, e apresentamos o OmDet-Turbo. Este novo modelo de OVD em tempo real baseado em transformers apresenta um módulo inovador de Cabeça de Fusão Eficiente (EFH) projetado para aliviar os gargalos observados no OmDet e no Grounding-DINO. Notavelmente, o OmDet-Turbo-Base atinge 100,2 quadros por segundo (FPS) com a aplicação de técnicas de TensorRT e cache de linguagem. Notavelmente, em cenários zero-shot nos conjuntos de dados COCO e LVIS, o OmDet-Turbo atinge níveis de desempenho quase equivalentes aos dos modelos supervisionados de estado da arte atuais. Além disso, ele estabelece novos benchmarks de estado da arte no ODinW e no OVDEval, com um AP de 30,1 e um NMS-AP de 26,86, respectivamente. A praticidade do OmDet-Turbo em aplicações industriais é destacada por seu desempenho excepcional em conjuntos de dados de referência e pela sua velocidade de inferência superior, posicionando-o como uma escolha atraente para tarefas de detecção de objetos em tempo real.
OmDet-Turbo architecture overview. Taken from the original paper. Este modelo foi contribuído por yonigozlan. O código original pode ser encontrado aqui.
Dicas de uso
Uma propriedade única do OmDet-Turbo em comparação com outros modelos de detecção de objetos zero-shot, como o Grounding DINO, é a estrutura desacoplada de classes e embeddings de prompt, que permite o cache de embeddings de texto. Isso significa que o modelo requer tanto classes quanto a tarefa como entradas, em que classes é uma lista de objetos que queremos detectar e task é o texto ancorado usado para orientar a detecção de vocabulário aberto. Essa abordagem limita o escopo da detecção de vocabulário aberto e torna o processo de decodificação mais rápido.
OmDetTurboProcessor é usado para preparar a tríade de classes, tarefa e imagem. A entrada de tarefa é opcional e, quando não fornecida, o valor padrão será "Detect [class1], [class2], [class3], ...". Para processar os resultados do modelo, é possível usar post_process_grounded_object_detection de OmDetTurboProcessor. Notavelmente, essa função recebe as classes de entrada, pois, ao contrário de outros modelos de detecção de objetos zero-shot, o desacoplamento dos embeddings de classes e de tarefa significa que não é necessário decodificar os embeddings de classe previstos na etapa de pós-processamento, e as classes previstas podem ser correspondidas diretamente às fornecidas.
Exemplo de uso
Inferência de uma única imagem
Aqui está como carregar o modelo e preparar as entradas para realizar a detecção de objetos zero-shot em uma única imagem:
import torch
import requests
from PIL import Image
from transformers import AutoProcessor, OmDetTurboForObjectDetection
processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
text_labels = ["cat", "remote"]
inputs = processor(image, text=text_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
outputs,
target_sizes=[(image.height, image.width)],
text_labels=text_labels,
threshold=0.3,
nms_threshold=0.3,
)
result = results[0]
boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"]
for box, score, text_label in zip(boxes, scores, text_labels):
box = [round(i, 2) for i in box.tolist()]
print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}")
Detected remote with confidence 0.768 at location [39.89, 70.35, 176.74, 118.04]
Detected cat with confidence 0.72 at location [11.6, 54.19, 314.8, 473.95]
Detected remote with confidence 0.563 at location [333.38, 75.77, 370.7, 187.03]
Detected cat with confidence 0.552 at location [345.15, 23.95, 639.75, 371.67]Inferência com múltiplas imagens
O OmDet-Turbo pode executar inferência em lote com múltiplas imagens, com suporte a diferentes prompts de texto e classes no mesmo lote:
import torch
import requests
from io import BytesIO
from PIL import Image
from transformers import AutoProcessor, OmDetTurboForObjectDetection
processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")
url1 = "http://images.cocodataset.org/val2017/000000039769.jpg"
image1 = Image.open(BytesIO(requests.get(url1).content)).convert("RGB")
text_labels1 = ["cat", "remote"]
task1 = "Detect {}.".format(", ".join(text_labels1))
url2 = "http://images.cocodataset.org/train2017/000000257813.jpg"
image2 = Image.open(BytesIO(requests.get(url2).content)).convert("RGB")
text_labels2 = ["boat"]
task2 = "Detect everything that looks like a boat."
url3 = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"
image3 = Image.open(BytesIO(requests.get(url3).content)).convert("RGB")
text_labels3 = ["statue", "trees"]
task3 = "Focus on the foreground, detect statue and trees."
inputs = processor(
images=[image1, image2, image3],
text=[text_labels1, text_labels2, text_labels3],
task=[task1, task2, task3],
return_tensors="pt",
)
with torch.no_grad():
outputs = model(**inputs)
# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
outputs,
text_labels=[text_labels1, text_labels2, text_labels3],
target_sizes=[(image.height, image.width) for image in [image1, image2, image3]],
threshold=0.2,
nms_threshold=0.3,
)
for i, result in enumerate(results):
for score, text_label, box in zip(
result["scores"], result["text_labels"], result["boxes"]
):
box = [round(i, 1) for i in box.tolist()]
print(
f"Detected {text_label} with confidence "
f"{round(score.item(), 2)} at location {box} in image {i}"
)
Detected remote with confidence 0.77 at location [39.9, 70.4, 176.7, 118.0] in image 0
Detected cat with confidence 0.72 at location [11.6, 54.2, 314.8, 474.0] in image 0
Detected remote with confidence 0.56 at location [333.4, 75.8, 370.7, 187.0] in image 0
Detected cat with confidence 0.55 at location [345.2, 24.0, 639.8, 371.7] in image 0
Detected boat with confidence 0.32 at location [146.9, 219.8, 209.6, 250.7] in image 1
Detected boat with confidence 0.3 at location [319.1, 223.2, 403.2, 238.4] in image 1
Detected boat with confidence 0.27 at location [37.7, 220.3, 84.0, 235.9] in image 1
Detected boat with confidence 0.22 at location [407.9, 207.0, 441.7, 220.2] in image 1
Detected statue with confidence 0.73 at location [544.7, 210.2, 651.9, 502.8] in image 2
Detected trees with confidence 0.25 at location [3.9, 584.3, 391.4, 785.6] in image 2
Detected trees with confidence 0.25 at location [1.4, 621.2, 118.2, 787.8] in image 2
Detected statue with confidence 0.2 at location [428.1, 205.5, 767.3, 759.5] in image 2
OmDetTurboConfig
classe transformers.OmDetTurboConfig
< 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneapply_layernorm_after_vision_backbone: bool = Trueimage_size: int | list[int] | tuple[int, int] = 640disable_custom_kernels: bool = Falselayer_norm_eps: float = 1e-05batch_norm_eps: float = 1e-05init_std: float = 0.02text_projection_in_dim: int = 512text_projection_out_dim: int = 512task_encoder_hidden_dim: int = 1024class_embed_dim: int = 512class_distance_type: typing.Literal['cosine', 'dot'] = 'cosine'num_queries: int = 900csp_activation: str = 'silu'conv_norm_activation: str = 'gelu'encoder_feedforward_activation: str = 'relu'encoder_feedforward_dropout: float | int = 0.0encoder_dropout: float | int = 0.0hidden_expansion: int = 1encoder_hidden_dim: int = 256vision_features_channels: list[int] | tuple[int, ...] = (256, 256, 256)encoder_in_channels: list[int] | tuple[int, ...] = (192, 384, 768)encoder_projection_indices: list[int] | tuple[int, ...] = (2,)encoder_attention_heads: int = 8encoder_dim_feedforward: int = 2048encoder_layers: int = 1positional_encoding_temperature: int = 10000num_feature_levels: int = 3decoder_hidden_dim: int = 256decoder_num_heads: int = 8decoder_num_layers: int = 6decoder_activation: str = 'relu'decoder_dim_feedforward: int = 2048decoder_num_points: int = 4decoder_dropout: float | int = 0.0eval_size: int | None = Nonelearn_initial_query: bool = Falsecache_size: int = 100 )
Parâmetros
- is_encoder_decoder (
bool, opcional, padrãoTrue) — Indica se o modelo é usado como encoder/decoder ou não. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto. - backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — A configuração do modelo backbone. - apply_layernorm_after_vision_backbone (
bool, opcional, padrãoTrue) — Se deve aplicar normalização de camada nos mapas de características da saída do backbone de visão. - image_size (
Union[int, list[int], tuple[int, int]], opcional, padrão640) — O tamanho (resolução) de cada imagem. - disable_custom_kernels (
bool, opcional, padrãoFalse) — Se deve desativar os kernels personalizados. - layer_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização de camada. - batch_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização de lote. - init_std (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - text_projection_in_dim (
int, opcional, padrão 512) — A dimensão de entrada para a projeção de texto. - text_projection_out_dim (
int, opcional, padrão 512) — A dimensão de saída para a projeção de texto. - task_encoder_hidden_dim (
int, opcional, padrão 1024) — A dimensão do feedforward para o codificador de tarefa. - class_embed_dim (
int, opcional, padrão 512) — A dimensão dos embeddings de classes. - class_distance_type (
str, opcional, padrão"cosine") — O tipo de distância para comparar as classes previstas com os embeddings das classes projetadas. Pode ser"cosine"ou"dot". - num_queries (
int, opcional, padrão 900) — O número de consultas. - csp_activation (
str, opcional, padrão"silu") — A função de ativação das redes Cross Stage Partial (CSP) do codificador. - conv_norm_activation (
str, opcional, padrão"gelu") — A função de ativação das camadas ConvNormLayer do codificador. - encoder_feedforward_activation (
str, opcional, padrão"relu") — A função de ativação da rede feedforward do codificador. - encoder_feedforward_dropout (
float, opcional, padrão 0.0) — A taxa de dropout após a ativação da rede feedforward do codificador. - encoder_dropout (
Union[float, int], opcional, padrão0.0) — A proporção para todas as camadas de dropout. - hidden_expansion (
int, opcional, padrão 1) — A expansão oculta das redes CSP no codificador. - encoder_hidden_dim (
int, opcional, padrão256) — Dimensão das representações ocultas. - vision_features_channels (
tuple(int), opcional, padrão[256, 256, 256]) — Os canais de recursos visuais projetados usados como entradas para o decodificador. - encoder_in_channels (
List(int), opcional, padrão[192, 384, 768]) — Os canais de entrada para o encoder. - encoder_projection_indices (
List(int), opcional, padrão[2]) — Os índices dos recursos de entrada projetados por cada camada. - encoder_attention_heads (
int, opcional, padrão8) — Número de cabeças de atenção para cada camada de atenção no codificador do Transformer. - encoder_dim_feedforward (
int, opcional, padrão 2048) — A dimensão do feedforward para o encoder. - encoder_layers (
int, opcional, padrão1) — Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor denum_layersse não for definido. - positional_encoding_temperature (
int, opcional, padrão 10000) — A temperatura da codificação posicional no codificador. - num_feature_levels (
int, opcional, padrão 3) — O número de níveis de características para o módulo de atenção deformável multiescala do decodificador. - decoder_hidden_dim (
int, opcional, padrão256) — Dimensão das representações ocultas. - decoder_num_heads (
int, opcional, padrão8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - decoder_num_layers (
int, opcional, padrão6) — Número de camadas ocultas no decodificador do Transformer. Se não for definido, usará o mesmo valor denum_layers. - decoder_activation (
str, opcional, padrão"relu") — A função de ativação do decodificador. - decoder_dim_feedforward (
int, opcional, padrão 2048) — A dimensão do feedforward para o decoder. - decoder_num_points (
int, opcional, padrão 4) — O número de pontos amostrados no módulo de atenção deformável multiescala do decodificador. - decoder_dropout (
float, opcional, padrão 0.0) — A taxa de dropout para o decodificador. - eval_size (
tuple[int, int], opcional) — Altura e largura usadas para calcular a altura e a largura efetivas dos embeddings de posição após considerar o stride (veja RTDetr). - learn_initial_query (
bool, opcional, padrãoFalse) — Se deve aprender a consulta inicial. - cache_size (
int, opcional, padrão 100) — O tamanho do cache para os caches de classes e prompts.
Esta é a classe de configuração para armazenar a configuração de um Omdet TurboModel. Ela é usada para instanciar um modelo Omdet Turbo 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 omlab/omdet-turbo-swin-tiny-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.
Exemplos:
>>> from transformers import OmDetTurboConfig, OmDetTurboForObjectDetection
>>> # Initializing a OmDet-Turbo omlab/omdet-turbo-swin-tiny-hf style configuration
>>> configuration = OmDetTurboConfig()
>>> # Initializing a model (with random weights) from the omlab/omdet-turbo-swin-tiny-hf style configuration
>>> model = OmDetTurboForObjectDetection(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOmDetTurboProcessor
classe transformers.OmDetTurboProcessor
< source >( image_processortokenizer )
Constrói um OmDetTurboProcessor que encapsula um processador de imagem e um tokenizer em um único processador.
OmDetTurboProcessor oferece todas as funcionalidades de DetrImageProcessor e CLIPTokenizer. Consulte ~DetrImageProcessor e ~CLIPTokenizer para mais informações.
__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] = Nonetext: list[str] | list[list[str]] | None = None**kwargs: *<class 'transformers.models.omdet_turbo.processing_omdet_turbo.OmDetTurboProcessorKwargs'> ) → ~feature_extraction_utils.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, definado_rescale=False. - text (
Union[list[str], list[list[str]]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, definais_split_into_words=Truepara evitar ambiguidade com entradas em lote. - task (
str, kwargs,list[str],TextInputouPreTokenizedInput, opcional) — A(s) descrição(ões) da tarefa de detecção a ser codificada. Se não for fornecida, uma descrição de tarefa padrão é gerada a partir da entradatext(por exemplo, “Detect {text}.”). Pode ser uma única string, uma lista de strings (uma por imagem) ou uma entrada pré-tokenizada. A descrição da tarefa orienta o modelo sobre quais objetos detectar nas imagens. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo NumPy.
- **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.
Retorna
~feature_extraction_utils.BatchFeature
- data (
dict, opcional) — Dicionário de listas/arrays/tensors retornados pelos métodos call/pad (‘input_values’, ‘attention_mask’, 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. - skip_tensor_conversion (
list[str]ouset[str], opcional) — Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quandotensor_typefor especificado.
post_process_grounded_object_detection
< source >( outputs: OmDetTurboObjectDetectionOutputtext_labels: list[str] | list[list[str]] | None = Nonethreshold: float = 0.3nms_threshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = Nonemax_num_det: int | None = None ) → list[Dict]
Parâmetros
- outputs (
OmDetTurboObjectDetectionOutput) — Saídas brutas do modelo. - text_labels (Union[list[str], list[list[str]]], opcional) —
Os nomes das classes de entrada. Se não for fornecido,
text_labelsserá definido comoNoneemoutputs. - threshold (float, padrão 0,3) — Retorne apenas detecções com uma pontuação de confiança superior a esse limite.
- nms_threshold (float, padrão 0.5) — O limiar a ser usado para a supressão de não máximo das caixas. Valor em [0, 1].
- target_sizes (
torch.Tensoroulist[tuple[int, int]], opcional) — Tensor de forma(batch_size, 2)ou lista de tuplas (tuple[int, int]) contendo o tamanho alvo(height, width)de cada imagem no lote. Se não definido, as previsões não serão redimensionadas. - max_num_det (
int, opcional) — O número máximo de detecções a serem retornadas.
Retorna
list[Dict]
Uma lista de dicionários, em que cada dicionário contém as pontuações, as classes e as caixas para uma imagem do lote, conforme previsto pelo modelo.
Converte a saída bruta de OmDetTurboForObjectDetection em caixas delimitadoras finais no formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y) e obtém a classe de texto associada.
OmDetTurboForObjectDetection
classe transformers.OmDetTurboForObjectDetection
< source >( config: OmDetTurboConfig )
Parâmetros
- config (OmDetTurboConfig) — 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.
Saída do modelo OmDetTurbo (composto por um backbone de visão e um backbone de texto, e arquitetura encoder-decoder) de caixas delimitadoras e pontuações de classes para tarefas como detecção COCO.
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: Tensorclasses_input_ids: LongTensorclasses_attention_mask: LongTensortasks_input_ids: LongTensortasks_attention_mask: LongTensorclasses_structure: LongTensorlabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → OmDetTurboObjectDetectionOutput or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando DetrImageProcessor. Consulte DetrImageProcessor.call() para obter detalhes (OmDetTurboProcessor usa DetrImageProcessor para processar imagens). - classes_input_ids (
torch.LongTensorde forma(total_classes (>= batch_size), sequence_length)) — Índices dos tokens da sequência de classes de entrada no vocabulário do modelo de linguagem. Várias classes podem ser fornecidas para cada tarefa, portanto, as classes tokenizadas são achatadas e a estrutura das classes é fornecida noclasses_structureargumento.Os índices podem ser obtidos usando OmDetTurboProcessor. Consulte OmDetTurboProcessor.call() para obter detalhes.
- classes_attention_mask (
torch.BoolTensorde forma(total_classes (>= batch_size), num_classes, sequence_length)) — Máscara de atenção para as classes. Esta é uma máscara binária que indica quais tokens devem ser considerados na atenção e quais não devem. - tasks_input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de tarefas de entrada no vocabulário do modelo de linguagem. Os índices podem ser obtidos usando OmDetTurboProcessor. Consulte OmDetTurboProcessor.call() para mais detalhes. O que são IDs de entrada?Os índices podem ser obtidos usando OmDetTurboProcessor. Consulte OmDetTurboProcessor.call() para obter detalhes.
- tasks_attention_mask (
torch.BoolTensorde forma(batch_size, sequence_length)) — Máscara de atenção para as tarefas. Esta é uma máscara binária que indica quais tokens devem ser considerados na atenção e quais não devem. - classes_structure (
torch.LongTensorde forma(batch_size)) — Estrutura das classes. Este tensor indica o número de classes para cada tarefa. - labels (
list[Dict]de comprimento(batch_size,), opcional) — Rótulos para o cálculo da perda de correspondência bipartida. Lista de dicionários, em que cada dicionário contém pelo menos as seguintes 2 chaves: ‘class_labels’ e ‘boxes’ (os rótulos de classe e as caixas delimitadoras de uma imagem no lote, respectivamente). Os próprios rótulos de classe devem ser umtorch.LongTensorde comprimento(number of bounding boxes in the image,)e as caixas umtorch.Tensorde forma(number of bounding boxes in the image, 4). - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
OmDetTurboObjectDetectionOutput ou tuple(torch.Tensor)
Um OmDetTurboObjectDetectionOutput 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 (OmDetTurboConfig) e das entradas.
O método forward da OmDetTurboForObjectDetection 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.
- loss (
torch.Tensor, opcional) — O valor da perda. - decoder_coord_logits (
torch.Tensorde forma(batch_size, num_queries, 4)) — Os logits das coordenadas previstas dos objetos. - decoder_class_logits (
torch.Tensorde forma(batch_size, num_queries, num_classes)) — A classe prevista dos objetos. - init_reference_points (
torch.Tensorde forma(batch_size, num_queries, 4)) — Os pontos de referência iniciais. - intermediate_reference_points (
tuple[tuple[torch.Tensor]], opcional) — Os pontos de referência intermediários. - encoder_coord_logits (
torch.Tensorde forma(batch_size, num_queries, 4)) — As coordenadas previstas dos objetos pelo encoder. - encoder_class_logits (
tuple[torch.Tensor], opcional) — A classe prevista dos objetos pelo encoder. - encoder_extracted_states (
torch.Tensor, opcional) — Os estados extraídos da Feature Pyramid Network (FPN) e da Path Aggregation Network (PAN) do encoder. - decoder_hidden_states (
tuple[torch.Tensor], opcional) — Tupla detorch.Tensor(um para a saída dos embeddings + um para a saída de cada camada) com formato(batch_size, sequence_length, hidden_size). Estados ocultos do modelo na saída de cada camada, além das saídas dos embeddings iniciais. - decoder_attentions (
tuple[tuple[torch.Tensor]], opcional) — Tupla de tuplas detorch.Tensor(uma para a atenção de cada camada) com a forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção, atenção cruzada e atenção deformável multiescala. - encoder_hidden_states (
tuple[torch.Tensor], opcional) — Tupla detorch.Tensor(um para a saída dos embeddings + um para a saída de cada camada) com formato(batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada além das saídas dos embeddings iniciais. - encoder_attentions (
tuple[tuple[torch.Tensor]], opcional) — Tupla de tuplas detorch.Tensor(uma para a atenção de cada camada) com a forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção, atenção cruzada e atenção deformável multiescala. - classes_structure (
torch.LongTensor, opcional) — O número de classes consultadas para cada imagem.
Exemplos:
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> from transformers import AutoProcessor, OmDetTurboForObjectDetection
>>> processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
>>> model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> classes = ["cat", "remote"]
>>> task = "Detect {}.".format(", ".join(classes))
>>> inputs = processor(image, text=classes, task=task, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits)
>>> results = processor.post_process_grounded_object_detection(
... outputs,
... classes=classes,
... target_sizes=[image.size[::-1]],
... score_threshold=0.3,
... nms_threshold=0.3,
>>> )[0]
>>> for score, class_name, box in zip(results["scores"], results["classes"], results["boxes"]):
... box = [round(i, 1) for i in box.tolist()]
... print(
... f"Detected {class_name} with confidence "
... f"{round(score.item(), 2)} at location {box}"
... )
Detected remote with confidence 0.76 at location [39.9, 71.3, 176.5, 117.9]
Detected cat with confidence 0.72 at location [345.1, 22.5, 639.7, 371.9]
Detected cat with confidence 0.65 at location [12.7, 53.8, 315.5, 475.3]
Detected remote with confidence 0.57 at location [333.4, 75.6, 370.7, 187.0]