Transformers documentation

RT-DETR

Transformers

Comece agora

Transformers Instalação Início rápido

Classes base

Modelos

Pré-processadores

Inferência

Pipeline API

API de geração

Otimização

Conversar com modelos

Serving

Treinamento

Comece agora

Personalização

Ajuste fino de parâmetros eficientes

Desempenho

Treinamento distribuído

Hardware

Quantização

Integrações com o ecossistema

Recursos

API

Principais classes

Modelos

Modelos de texto

Modelos de visão

Modelos de áudio

Modelos de vídeo

Modelos multimodais

Modelos de aprendizado por reforço

Modelos de séries temporais

Helpers internos

Referência

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo foi publicado no HF papers em 2023-04-17 e contribuído para o Hugging Face Transformers em 2024-06-22.

RT-DETR

Visão geral

O modelo RT-DETR foi proposto em DETRs Beat YOLOs on Real-time Object Detection por Wenyu Lv, Yian Zhao, Shangliang Xu, Jinman Wei, Guanzhong Wang, Cheng Cui, Yuning Du, Qingqing Dang, Yi Liu.

RT-DETR é um modelo de detecção de objetos que significa “Real-Time DEtection Transformer”. Este modelo foi projetado para executar tarefas de detecção de objetos com foco em alcançar desempenho em tempo real, mantendo alta precisão. Aproveitando a arquitetura transformer, que ganhou grande popularidade em diversas áreas do deep learning, o RT-DETR processa imagens para identificar e localizar múltiplos objetos nelas.

O resumo do artigo é o seguinte:

Recentemente, detectores baseados em transformers de ponta a ponta (DETRs) alcançaram desempenho notável. No entanto, o problema do alto custo computacional dos DETRs não foi efetivamente resolvido, o que limita sua aplicação prática e impede que aproveitem plenamente os benefícios da ausência de pós-processamento, como a supressão de máximos não máximos (NMS). Neste artigo, primeiro analisamos a influência da NMS em detectores de objetos em tempo real modernos na velocidade de inferência e estabelecemos um benchmark de velocidade de ponta a ponta. Para evitar o atraso de inferência causado pela NMS, propomos o Real-Time DEtection TRansformer (RT-DETR), o primeiro detector de objetos em tempo real de ponta a ponta, até onde temos conhecimento. Especificamente, projetamos um codificador híbrido eficiente para processar recursos multiescala de forma eficiente, desacoplando a interação intraescala e a fusão entre escalas, e propomos a seleção de consultas consciente de IoU para melhorar a inicialização das consultas de objetos. Além disso, nosso detector proposto permite o ajuste flexível da velocidade de inferência usando diferentes camadas do decodificador, sem a necessidade de re-treinamento, o que facilita a aplicação prática de detectores de objetos em tempo real. Nosso RT-DETR-L alcança 53,0% de AP no COCO val2017 e 114 FPS em GPU T4, enquanto o RT-DETR-X alcança 54,8% de AP e 74 FPS, superando todos os detectores YOLO da mesma escala tanto em velocidade quanto em precisão. Além disso, nosso RT-DETR-R50 alcança 53,1% de AP e 108 FPS, superando o DINO-Deformable-DETR-R50 em 2,2% de AP em precisão e em aproximadamente 21 vezes em FPS.

RT-DETR performance relative to YOLO models. Taken from the original paper.

A versão do modelo foi contribuída por rafaelpadilla e sangbumchoi. O código original pode ser encontrado aqui.

Dicas de uso

Inicialmente, uma imagem é processada usando uma rede neural convolucional pré-treinada, especificamente uma variante Resnet-D, conforme referenciado no código original. Esta rede extrai recursos das três camadas finais da arquitetura. Em seguida, um codificador híbrido é utilizado para converter os recursos multiescala em um array sequencial de recursos de imagem. Depois, um decodificador, equipado com cabeças de previsão auxiliares, é usado para refinar as consultas de objeto. Esse processo facilita a geração direta de caixas delimitadoras, eliminando a necessidade de qualquer pós-processamento adicional para obter os logits e as coordenadas das caixas delimitadoras. O modelo deve ser usado em imagens redimensionadas para o tamanho 640x640 com o ImageProcessor correspondente. Redimensionar para outros tamanhos geralmente degradará o desempenho.

import requests
import torch
from PIL import Image

from transformers import RTDetrForObjectDetection, RTDetrImageProcessor


url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([(image.height, image.width)]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
sofa: 0.97 [0.14, 0.38, 640.13, 476.21]
cat: 0.96 [343.38, 24.28, 640.14, 371.5]
cat: 0.96 [13.23, 54.18, 318.98, 472.22]
remote: 0.95 [40.11, 73.44, 175.96, 118.48]
remote: 0.92 [333.73, 76.58, 369.97, 186.99]

Recursos

Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o RT-DETR.

Object Detection

Veja também: Guia da tarefa de detecção de objetos.
Notebooks sobre inferência e ajuste fino do RT-DETR em um conjunto de dados personalizado podem ser encontrados aqui. 🌎

RTDetrConfig

classe transformers.RTDetrConfig

< 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 = Trueinitializer_range: float = 0.01initializer_bias_prior_prob: float | None = Nonelayer_norm_eps: float = 1e-05batch_norm_eps: float = 1e-05backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefreeze_backbone_batch_norms: bool = Trueencoder_hidden_dim: int = 256encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048)feat_strides: list[int] | tuple[int, ...] = (8, 16, 32)encoder_layers: int = 1encoder_ffn_dim: int = 1024encoder_attention_heads: int = 8dropout: float | int = 0.0activation_dropout: float | int = 0.0encode_proj_layers: list[int] | tuple[int, ...] = (2,)positional_encoding_temperature: int = 10000encoder_activation_function: str = 'gelu'activation_function: str = 'silu'eval_size: int | None = Nonenormalize_before: bool = Falsehidden_expansion: float = 1.0d_model: int = 256num_queries: int = 300decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256)decoder_ffn_dim: int = 1024num_feature_levels: int = 3decoder_n_points: int = 4decoder_layers: int = 6decoder_attention_heads: int = 8decoder_activation_function: str = 'relu'attention_dropout: float | int = 0.0num_denoising: int = 100label_noise_ratio: float = 0.5box_noise_scale: float = 1.0learn_initial_query: bool = Falseanchor_image_size: int | list[int] | None = Nonedisable_custom_kernels: bool = Truewith_box_refine: bool = Truematcher_alpha: float = 0.25matcher_gamma: float = 2.0matcher_class_cost: float = 2.0matcher_bbox_cost: float = 5.0matcher_giou_cost: float = 2.0use_focal_loss: bool = Trueauxiliary_loss: bool = Truefocal_loss_alpha: float = 0.75focal_loss_gamma: float = 2.0weight_loss_vfl: float = 1.0weight_loss_bbox: float = 5.0weight_loss_giou: float = 2.0eos_coefficient: float = 0.0001 )

Parâmetros

is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
initializer_range (float, opcional, padrão 0.01) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
initializer_bias_prior_prob (float, opcional) — A probabilidade a priori usada pelo inicializador de viés para inicializar os vieses de enc_score_head e class_embed. Se None, prior_prob é calculado como prior_prob = 1 / (num_labels + 1) durante a inicialização dos pesos do modelo.
layer_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
batch_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de lote.
backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — A configuração do modelo backbone.
freeze_backbone_batch_norms (bool, opcional, padrão True) — Se as camadas de normalização de lote no backbone devem ser congeladas.
encoder_hidden_dim (int, opcional, padrão 256) — Dimensão das representações ocultas.
encoder_in_channels (list, opcional, padrão [512, 1024, 2048]) — Entrada de recursos em múltiplos níveis para o codificador.
feat_strides (list[int], opcional, padrão [8, 16, 32]) — Passos usados em cada mapa de características.
encoder_layers (int, opcional, padrão 1) — Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de num_layers se não for definido.
encoder_ffn_dim (int, opcional, padrão 1024) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no encoder.
encoder_attention_heads (int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.
dropout (Union[float, int], opcional, padrão 0.0) — A proporção para todas as camadas de dropout.
activation_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as ativações dentro da camada totalmente conectada.
encode_proj_layers (list[int], opcional, padrão [2]) — Índices das camadas projetadas a serem usadas no codificador.
positional_encoding_temperature (int, opcional, padrão 10000) — O parâmetro de temperatura usado para criar as codificações posicionais.
encoder_activation_function (str, opcional, padrão "gelu") — A função de ativação não linear (função ou string) no encoder e no pooler. Se for string, "gelu", "relu", "silu" e "gelu_new" são suportadas.
activation_function (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
eval_size (tuple[int, int], opcional) — Altura e largura usadas para calcular a altura e a largura efetivas dos embeddings de posição, considerando o stride.
normalize_before (bool, opcional, padrão False) — Determina se a normalização de camada deve ser aplicada na camada do codificador do transformer antes dos módulos de autoatenção e de rede feed-forward.
hidden_expansion (float, opcional, padrão 1.0) — Razão de expansão para aumentar o tamanho da dimensão de RepVGGBlock e CSPRepLayer.
d_model (int, opcional, padrão 256) — Tamanho das camadas do codificador e da camada pooler.
num_queries (int, opcional, padrão 300) — Número de consultas de objeto.
decoder_in_channels (list, opcional, padrão [256, 256, 256]) — Dimensão dos recursos em múltiplos níveis para o decodificador
decoder_ffn_dim (int, opcional, padrão 1024) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no decoder.
num_feature_levels (int, opcional, padrão 3) — O número de níveis de recursos de entrada.
decoder_n_points (int, opcional, padrão 4) — O número de chaves amostradas em cada nível de recurso para cada cabeça de atenção no decoder.
decoder_layers (int, opcional, padrão 6) — Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de num_layers se não for definido.
decoder_attention_heads (int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
decoder_activation_function (str, opcional, padrão "relu") — A função de ativação não linear (função ou string) no decodificador. Se for string, "gelu", "relu", "silu" e "gelu_new" são suportadas.
attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
num_denoising (int, opcional, padrão 100) — O número total de tarefas ou consultas de desruido a serem usadas para o desruido contrastivo.
label_noise_ratio (float, opcional, padrão 0.5) — A fração de rótulos de desruidamento à qual o ruído aleatório deve ser adicionado.
box_noise_scale (float, opcional, padrão 1.0) — Escala ou magnitude do ruído a ser adicionado às bounding boxes.
learn_initial_query (bool, opcional, padrão False) — Indica se os embeddings de consulta inicial do decodificador devem ser aprendidos durante o treinamento
anchor_image_size (tuple[int, int], opcional) — Altura e largura da imagem de entrada usada durante a avaliação para gerar as âncoras de bounding box. Se for None, a geração automática de âncoras é aplicada.
disable_custom_kernels (bool, opcional, padrão True) — Se deve desativar os kernels personalizados.
with_box_refine (bool, opcional, padrão True) — Se deve aplicar refinamento iterativo de caixas delimitadoras, em que cada camada do decodificador refina as caixas delimitadoras com base nas previsões da camada anterior.
matcher_alpha (float, opcional, padrão 0.25) — Parâmetro alpha usado pelo Hungarian Matcher.
matcher_gamma (float, opcional, padrão 2.0) — Parâmetro gamma usado pelo Hungarian Matcher.
matcher_class_cost (float, opcional, padrão 2.0) — O peso relativo da perda de classe usado pelo Hungarian Matcher.
matcher_bbox_cost (float, opcional, padrão 5.0) — O peso relativo da perda de caixa delimitadora usado pelo Hungarian Matcher.
matcher_giou_cost (float, opcional, padrão 2.0) — O peso relativo da perda giou usada pelo Hungarian Matcher.
use_focal_loss (bool, opcional, padrão True) — Parâmetro que informa se a focal loss deve ser utilizada.
auxiliary_loss (bool, opcional, padrão True) — Se as perdas de decodificação auxiliares (perdas em cada camada do decodificador) devem ser usadas.
focal_loss_alpha (float, opcional, padrão 0.75) — Parâmetro alpha usado para calcular a focal loss.
focal_loss_gamma (float, opcional, padrão 2.0) — Parâmetro gamma usado para calcular a focal loss.
weight_loss_vfl (float, opcional, padrão 1.0) — Peso relativo da perda varifocal na perda de detecção de objetos.
weight_loss_bbox (float, opcional, padrão 5.0) — Peso relativo da perda L1 da caixa delimitadora na perda de detecção de objetos.
weight_loss_giou (float, opcional, padrão 2.0) — Peso relativo da perda de IoU generalizada na perda de detecção de objetos.
eos_coefficient (float, opcional, padrão 0.0001) — Peso de classificação relativo da classe 'no-object' na perda de detecção de objetos.

Esta é a classe de configuração para armazenar a configuração de um RTDetrModel. Ela é usada para instanciar um modelo Rt Detr 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 PekingU/rtdetr_r50vd

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 RTDetrConfig, RTDetrModel

>>> # Initializing a RT-DETR configuration
>>> configuration = RTDetrConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = RTDetrModel(configuration)

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

RTDetrResNetConfig

classe transformers.RTDetrResNetConfig

< source >

Parâmetros

num_channels (int, opcional, padrão 3) — O número de canais de entrada.
embedding_size (int, opcional, padrão 64) — Dimensão dos embeddings e dos estados ocultos.
hidden_sizes (Union[list[int], tuple[int, ...]], opcional, padrão (256, 512, 1024, 2048)) — Dimensão (tamanho oculto) em cada etapa do modelo.
depths (list[int], opcional, padrão [3, 4, 6, 3]) — Profundidade (número de camadas) para cada estágio.
layer_type (str, opcional, padrão "bottleneck") — A camada a ser utilizada, que pode ser "basic" (usada para modelos menores, como resnet-18 ou resnet-34) ou "bottleneck" (usada para modelos maiores, como resnet-50 e superiores).
hidden_act (str, opcional, padrão "relu") — A função de ativação não linear em cada bloco. Se for uma string, "gelu", "relu", "selu" e "gelu_new" são suportadas.
downsample_in_first_stage (bool, opcional, padrão False) — Se True, a primeira etapa reduz a resolução das entradas usando um stride de 2.
downsample_in_bottleneck (bool, opcional, padrão False) — Se True, a primeira conv 1x1 em ResNetBottleNeckLayer reduz a resolução das entradas usando um stride de 2.

Esta é a classe de configuração para armazenar a configuração de um Rt Detr ResnetModel. Ela é usada para instanciar um modelo Rt Detr Resnet 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 microsoft/resnet-50

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 RTDetrResNetConfig, RTDetrResnetBackbone

>>> # Initializing a ResNet resnet-50 style configuration
>>> configuration = RTDetrResNetConfig()

>>> # Initializing a model (with random weights) from the resnet-50 style configuration
>>> model = RTDetrResnetBackbone(configuration)

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

RTDetrImageProcessor

classe transformers.RTDetrImageProcessor

< source >

( **kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'> )

Parâmetros

do_convert_rgb (bool, kwargs, opcional) — 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' -- 640, 'width': 640}): Descreve as dimensões máximas de entrada para o modelo.
default_to_square (bool, kwargs, opcional, padrão False) — 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 2) — Filtro de reamostragem 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 False) — Indica 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, padrão False) — 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.
format (str, kwargs, opcional, padrão AnnotationFormat.COCO_DETECTION) — Formato dos dados das anotações. Um de “coco_detection” ou “coco_panoptic”.
do_convert_annotations (bool, kwargs, opcional, padrão True) — Controla se as anotações devem ser convertidas para o formato esperado pelo modelo RT_DETR. Converte as bounding boxes para o formato (center_x, center_y, width, height) e no intervalo [0, 1]. Pode ser sobrescrito pelo parâmetro do_convert_annotations no método preprocess.

Constrói um processador de imagem RTDetrImageProcessor.

pré-processamento

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = Nonereturn_segmentation_masks: bool | None = Nonemasks_path: str | pathlib.Path | None = None**kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'> ) → ~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]]) — 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.
annotations (AnnotationType ou list[AnnotationType], opcional) — Anotações a serem transformadas de acordo com o padding aplicado às imagens.
return_segmentation_masks (bool, opcional, padrão self.return_segmentation_masks) — Se deve retornar máscaras de segmentação.
masks_path (str ou pathlib.Path, opcional) — Caminho para o diretório que contém as máscaras de segmentação.
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.
format (str, kwargs, opcional, padrão AnnotationFormat.COCO_DETECTION) — Formato dos dados das anotações. Um de “coco_detection” ou “coco_panoptic”.
do_convert_annotations (bool, kwargs, opcional, padrão True) — Controla se as anotações devem ser convertidas para o formato esperado pelo modelo RT_DETR. Converte as bounding boxes para o formato (center_x, center_y, width, height) e no intervalo [0, 1]. Pode ser sobrescrito pelo parâmetro do_convert_annotations no método preprocess.

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_object_detection

< source >

( outputsthreshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] = Noneuse_focal_loss: bool = True ) → list[Dict]

Parâmetros

outputs (DetrObjectDetectionOutput) — Saídas brutas do modelo.
threshold (float, opcional, padrão 0.5) — Limiar de pontuação para manter as previsões de detecção de objetos.
target_sizes (torch.Tensor ou list[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.
use_focal_loss (bool padrão True) — Variável que informa se a focal loss foi usada para prever as saídas. Se True, uma sigmoid é aplicada para calcular as pontuações de cada detecção; caso contrário, uma função softmax é utilizada.

Retorna

list[Dict]

Uma lista de dicionários, em que cada dicionário contém as pontuações, rótulos e caixas para uma imagem do lote, conforme previsto pelo modelo.

Converte a saída bruta de DetrForObjectDetection em caixas delimitadoras finais no formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Suporta apenas PyTorch.

RTDetrImageProcessorPil

classe transformers.RTDetrImageProcessorPil

< source >

( **kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'> )

Parâmetros

do_convert_rgb (bool, kwargs, opcional) — 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' -- 640, 'width': 640}): Descreve as dimensões máximas de entrada para o modelo.
default_to_square (bool, kwargs, opcional, padrão False) — 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 2) — Filtro de reamostragem 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 False) — Indica 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, padrão False) — 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.
format (str, kwargs, opcional, padrão AnnotationFormat.COCO_DETECTION) — Formato dos dados das anotações. Um de “coco_detection” ou “coco_panoptic”.
do_convert_annotations (bool, kwargs, opcional, padrão True) — Controla se as anotações devem ser convertidas para o formato esperado pelo modelo RT_DETR. Converte as bounding boxes para o formato (center_x, center_y, width, height) e no intervalo [0, 1]. Pode ser sobrescrito pelo parâmetro do_convert_annotations no método preprocess.

Constrói um processador de imagem RTDetrImageProcessor.

pré-processamento

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = Nonereturn_segmentation_masks: bool | None = Nonemasks_path: str | pathlib.Path | None = None**kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'> ) → ~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]]) — 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.
annotations (AnnotationType ou list[AnnotationType], opcional) — Anotações a serem transformadas de acordo com o padding aplicado às imagens.
return_segmentation_masks (bool, opcional, padrão self.return_segmentation_masks) — Se deve retornar máscaras de segmentação.
masks_path (str ou pathlib.Path, opcional) — Caminho para o diretório que contém as máscaras de segmentação.
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.
format (str, kwargs, opcional, padrão AnnotationFormat.COCO_DETECTION) — Formato dos dados das anotações. Um de “coco_detection” ou “coco_panoptic”.
do_convert_annotations (bool, kwargs, opcional, padrão True) — Controla se as anotações devem ser convertidas para o formato esperado pelo modelo RT_DETR. Converte as bounding boxes para o formato (center_x, center_y, width, height) e no intervalo [0, 1]. Pode ser sobrescrito pelo parâmetro do_convert_annotations no método preprocess.

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_object_detection

< source >

( outputsthreshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] = Noneuse_focal_loss: bool = True ) → list[Dict]

Parâmetros

outputs (DetrObjectDetectionOutput) — Saídas brutas do modelo.
threshold (float, opcional, padrão 0.5) — Limiar de pontuação para manter as previsões de detecção de objetos.
target_sizes (torch.Tensor ou list[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.
use_focal_loss (bool padrão True) — Variável que informa se a focal loss foi usada para prever as saídas. Se True, uma sigmoid é aplicada para calcular as pontuações de cada detecção; caso contrário, uma função softmax é utilizada.

Retorna

list[Dict]

Uma lista de dicionários, em que cada dicionário contém as pontuações, rótulos e caixas para uma imagem do lote, conforme previsto pelo modelo.

Converte a saída bruta de DetrForObjectDetection em caixas delimitadoras finais no formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Suporta apenas PyTorch.

RTDetrModel

classe transformers.RTDetrModel

< source >

( config: RTDetrConfig )

Parâmetros

config (RTDetrConfig) — 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 RT-DETR (composto por um backbone e um encoder-decoder) que produz estados ocultos brutos, sem nenhum head 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: Tensorpixel_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → RTDetrModelOutput 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 image_processor_class. Consulte image_processor_class.__call__ para mais detalhes (processor_class usa image_processor_class para processar as imagens).
pixel_mask (torch.LongTensor de forma (batch_size, height, width), opcional) — Máscara para evitar a execução de atenção em valores de pixels de preenchimento. Valores da máscara selecionados em [0, 1]:
- 1 para pixels reais (ou seja, não mascarados),
- 0 para pixels que são padding (ou seja, mascarados).
O que são máscaras de atenção?
encoder_outputs (torch.Tensor, opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar o mapa de recursos achatado (saída do backbone + camada de projeção), você pode escolher passar diretamente uma representação achatada de uma imagem.
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 um torch.LongTensor de comprimento (number of bounding boxes in the image,) e as caixas um torch.Tensor de forma (number of bounding boxes in the image, 4).

Retorna

RTDetrModelOutput ou tuple(torch.Tensor)

Uma RTDetrModelOutput 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 (None) e das entradas.

O método forward do RTDetrModel 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, num_queries, hidden_size)) — Sequência de estados ocultos na saída da última camada do decodificador do modelo.
intermediate_hidden_states (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, hidden_size)) — Estados ocultos intermediários empilhados (saída de cada camada do decodificador).
intermediate_logits (torch.Tensor de forma (batch_size, config.decoder_layers, sequence_length, config.num_labels)) — Logits intermediários empilhados (logits de cada camada do decodificador).
intermediate_reference_points (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, 4)) — Pontos de referência intermediários empilhados (pontos de referência de cada camada do decodificador).
intermediate_predicted_corners (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, 4)) — Cantos intermediários previstos empilhados (cantos previstos de cada camada do decodificador).
initial_reference_points (torch.Tensor de forma (batch_size, num_queries, 4)) — Pontos de referência iniciais usados para a primeira camada do decodificador.
decoder_hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 decodificador na saída de cada camada, além das saídas do embedding inicial.
decoder_attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
cross_attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.
encoder_hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 codificador na saída de cada camada, além das saídas do embedding inicial.
encoder_attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
init_reference_points (torch.Tensor de forma (batch_size, num_queries, 4)) — Pontos de referência iniciais enviados através do decodificador do Transformer.
enc_topk_logits (torch.Tensor de forma (batch_size, sequence_length, config.num_labels)) — Pontuações das caixas delimitadoras previstas, nas quais as caixas delimitadoras com as config.two_stage_num_proposals maiores pontuações são selecionadas como propostas de região na etapa do codificador. Saída da classificação binária de caixas delimitadoras (ou seja, primeiro plano e segundo plano).
enc_topk_bboxes (torch.Tensor de forma (batch_size, sequence_length, 4)) — Logits das coordenadas das caixas delimitadoras previstas na etapa do codificador.
enc_outputs_class (torch.Tensor de forma (batch_size, sequence_length, config.num_labels), opcional, retornado quando config.with_box_refine=True e config.two_stage=True) — Pontuações das caixas delimitadoras previstas, onde as config.two_stage_num_proposals caixas delimitadoras com as maiores pontuações são selecionadas como propostas de região na primeira etapa. Saída da classificação binária de caixas delimitadoras (ou seja, primeiro plano e segundo plano).
enc_outputs_coord_logits (torch.Tensor de forma (batch_size, sequence_length, 4), opcional, retornado quando config.with_box_refine=True e config.two_stage=True) — Logits das coordenadas das caixas delimitadoras previstas na primeira etapa.
denoising_meta_values (dict, opcional) — Dicionário extra para os valores relacionados ao denoising.

Exemplos:

>>> from transformers import AutoImageProcessor, RTDetrModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
>>> model = RTDetrModel.from_pretrained("PekingU/rtdetr_r50vd")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]

RTDetrForObjectDetection

classe transformers.RTDetrForObjectDetection

< source >

( config: RTDetrConfig )

Parâmetros

config (RTDetrConfig) — 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 RT-DETR (composto por um backbone e um encoder-decoder) que gera bounding boxes e logits para serem decodificados em seguida em scores e classes.

forward

< source >

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 image_processor_class. Consulte image_processor_class.__call__ para mais detalhes (processor_class usa image_processor_class para processar as imagens).
pixel_mask (torch.LongTensor de forma (batch_size, height, width), opcional) — Máscara para evitar a execução de atenção em valores de pixels de preenchimento. Valores da máscara selecionados em [0, 1]:
- 1 para pixels reais (ou seja, não mascarados),
- 0 para pixels que são padding (ou seja, mascarados).
O que são máscaras de atenção?
encoder_outputs (torch.Tensor, opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar o mapa de recursos achatado (saída do backbone + camada de projeção), você pode escolher passar diretamente uma representação achatada de uma imagem.
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 um torch.LongTensor de comprimento (number of bounding boxes in the image,) e as caixas um torch.Tensor de forma (number of bounding boxes in the image, 4).

Retorna

RTDetrObjectDetectionOutput ou tuple(torch.Tensor)

Uma RTDetrObjectDetectionOutput 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 (None) e das entradas.

O método forward de RTDetrForObjectDetection 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.

loss (torch.Tensor de forma (1,), opcional, retornado quando labels são fornecidas)) — Perda total como uma combinação linear de uma log-verossimilhança negativa (entropia cruzada) para a previsão de classe e uma perda de caixa delimitadora. Esta última é definida como uma combinação linear da perda L1 e da perda de IoU generalizada e invariante à escala.
loss_dict (Dict, opcional) — Um dicionário contendo as perdas individuais. Útil para registro de logs.
logits (torch.Tensor de forma (batch_size, num_queries, num_classes + 1)) — Logits de classificação (incluindo no-object) para todas as queries.
pred_boxes (torch.Tensor de forma (batch_size, num_queries, 4)) — Coordenadas normalizadas das caixas para todas as queries, representadas como (center_x, center_y, width, height). Esses valores são normalizados em [0, 1], relativos ao tamanho de cada imagem individual no batch (ignorando qualquer padding possível). Você pode usar post_process_object_detection() para recuperar as caixas delimitadoras não normalizadas (absolutas).
auxiliary_outputs (list[Dict], opcional) — Opcional, retornado apenas quando as perdas auxiliares são ativadas (ou seja, config.auxiliary_loss está definido como True) e os rótulos são fornecidos. É uma lista de dicionários contendo as duas chaves acima (logits e pred_boxes) para cada camada do decodificador.
last_hidden_state (torch.Tensor de forma (batch_size, num_queries, hidden_size)) — Sequência de estados ocultos na saída da última camada do decodificador do modelo.
intermediate_hidden_states (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, hidden_size)) — Estados ocultos intermediários empilhados (saída de cada camada do decodificador).
intermediate_logits (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, config.num_labels)) — Logits intermediários empilhados (logits de cada camada do decodificador).
intermediate_reference_points (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, 4)) — Pontos de referência intermediários empilhados (pontos de referência de cada camada do decodificador).
intermediate_predicted_corners (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, 4)) — Cantos intermediários previstos empilhados (cantos previstos de cada camada do decodificador).
initial_reference_points (torch.Tensor de forma (batch_size, config.decoder_layers, num_queries, 4)) — Pontos de referência iniciais empilhados (pontos de referência iniciais de cada camada do decoder).
decoder_hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 decodificador na saída de cada camada, além das saídas do embedding inicial.
decoder_attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
cross_attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.
encoder_last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do codificador do modelo.
encoder_hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.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 codificador na saída de cada camada, além das saídas do embedding inicial.
encoder_attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
init_reference_points (torch.Tensor de forma (batch_size, num_queries, 4)) — Pontos de referência iniciais enviados através do decodificador do Transformer.
enc_topk_logits (torch.Tensor de forma (batch_size, sequence_length, config.num_labels), opcional, retornado quando config.with_box_refine=True e config.two_stage=True) — Logits das coordenadas das caixas delimitadoras previstas no codificador.
enc_topk_bboxes (torch.Tensor de forma (batch_size, sequence_length, 4), opcional, retornado quando config.with_box_refine=True e config.two_stage=True) — Logits das coordenadas das caixas delimitadoras previstas no codificador.
enc_outputs_class (torch.Tensor de forma (batch_size, sequence_length, config.num_labels), opcional, retornado quando config.with_box_refine=True e config.two_stage=True) — Pontuações das caixas delimitadoras previstas, onde as config.two_stage_num_proposals caixas delimitadoras com as maiores pontuações são selecionadas como propostas de região na primeira etapa. Saída da classificação binária de caixas delimitadoras (ou seja, primeiro plano e segundo plano).
enc_outputs_coord_logits (torch.Tensor de forma (batch_size, sequence_length, 4), opcional, retornado quando config.with_box_refine=True e config.two_stage=True) — Logits das coordenadas das caixas delimitadoras previstas na primeira etapa.
denoising_meta_values (dict, opcional) — Dicionário extra para os valores relacionados ao denoising

Exemplos:

>>> from transformers import RTDetrImageProcessor, RTDetrForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
>>> model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 300, 80]

>>> boxes = outputs.pred_boxes
>>> list(boxes.shape)
[1, 300, 4]

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]

>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected sofa with confidence 0.97 at location [0.14, 0.38, 640.13, 476.21]
Detected cat with confidence 0.96 at location [343.38, 24.28, 640.14, 371.5]
Detected cat with confidence 0.958 at location [13.23, 54.18, 318.98, 472.22]
Detected remote with confidence 0.951 at location [40.11, 73.44, 175.96, 118.48]
Detected remote with confidence 0.924 at location [333.73, 76.58, 369.97, 186.99]

RTDetrResNetBackbone

classe transformers.RTDetrResNetBackbone

< source >

( config: RTDetrResNetConfig )

Parâmetros

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

Backbone ResNet, para ser usado com frameworks como RTDETR.

forward

< source >

( pixel_values: Tensoroutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BackboneOutput 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 image_processor_class. Consulte image_processor_class.__call__ para mais detalhes (processor_class usa image_processor_class para processar as imagens).
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

BackboneOutput ou tuple(torch.Tensor)

Um BackboneOutput 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 (RTDetrResNetConfig) e das entradas.

O método forward de RTDetrResNetBackbone 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.

feature_maps (tuple(torch.Tensor) de forma (batch_size, num_channels, height, width)) — Mapas de características dos estágios.
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou 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, sequence_length, hidden_size) ou (batch_size, num_channels, height, width), dependendo do backbone.

Estados ocultos do modelo na saída de cada estágio, além das saídas do embedding inicial.

attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length). Aplicável apenas se o backbone usar atenção.

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

>>> from transformers import RTDetrResNetConfig, RTDetrResNetBackbone
>>> import torch
precation import deprecate_kwarg
precation import deprecate_kwarg
precation import deprecate_kwarg
utils.deprecation import deprecate_kwarg
utils.deprecation import deprecate_kwarg

>>> config = RTDetrResNetConfig()
>>> model = RTDetrResNetBackbone(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 2048, 7, 7]

Update on GitHub

←RF-DETR RT-DETRv2→