# RT-DETR ## Visão geral O modelo RT-DETR foi proposto em [DETRs Beat YOLOs on Real-time Object Detection](https://huggingface.co/papers/2304.08069) 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 de 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.* drawing Desempenho do RT-DETR em relação aos modelos YOLO. Retirado do artigo original. A versão do modelo foi contribuída por [rafaelpadilla](https://huggingface.co/rafaelpadilla) e [sangbumchoi](https://github.com/SangbumChoi). O código original pode ser encontrado [aqui](https://github.com/lyuwenyu/RT-DETR/). ## 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. ```python 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. - Veja também: [Guia da tarefa de detecção de objetos](../tasks/object_detection). - Notebooks sobre inferência e ajuste fino do RT-DETR em um conjunto de dados personalizado podem ser encontrados [aqui](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/RT-DETR). 🌎 ## RTDetrConfig[[transformers.RTDetrConfig]] #### transformers.RTDetrConfig[[transformers.RTDetrConfig]] ```python transformers.RTDetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, initializer_range: float = 0.01, initializer_bias_prior_prob: float | None = None, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, freeze_backbone_batch_norms: bool = True, encoder_hidden_dim: int = 256, encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048), feat_strides: list[int] | tuple[int, ...] = (8, 16, 32), encoder_layers: int = 1, encoder_ffn_dim: int = 1024, encoder_attention_heads: int = 8, dropout: float | int = 0.0, activation_dropout: float | int = 0.0, encode_proj_layers: list[int] | tuple[int, ...] = (2,), positional_encoding_temperature: int = 10000, encoder_activation_function: str = 'gelu', activation_function: str = 'silu', eval_size: int | None = None, normalize_before: bool = False, hidden_expansion: float = 1.0, d_model: int = 256, num_queries: int = 300, decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256), decoder_ffn_dim: int = 1024, num_feature_levels: int = 3, decoder_n_points: int = 4, decoder_layers: int = 6, decoder_attention_heads: int = 8, decoder_activation_function: str = 'relu', attention_dropout: float | int = 0.0, num_denoising: int = 100, label_noise_ratio: float = 0.5, box_noise_scale: float = 1.0, learn_initial_query: bool = False, anchor_image_size: int | list[int] | None = None, disable_custom_kernels: bool = True, with_box_refine: bool = True, matcher_alpha: float = 0.25, matcher_gamma: float = 2.0, matcher_class_cost: float = 2.0, matcher_bbox_cost: float = 5.0, matcher_giou_cost: float = 2.0, use_focal_loss: bool = True, auxiliary_loss: bool = True, focal_loss_alpha: float = 0.75, focal_loss_gamma: float = 2.0, weight_loss_vfl: float = 1.0, weight_loss_bbox: float = 5.0, weight_loss_giou: float = 2.0, eos_coefficient: float = 0.0001) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/configuration_rt_detr.py#L25) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador 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 encoder. 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`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador. 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 avanço. 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 decoder decoder_ffn_dim (`int`, *opcional*, padrão `1024`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador. 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 decodificador. 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 iniciais 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 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 da 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 usada. 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 de caixa delimitadora L1 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 relativo de classificação 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](https://huggingface.co/PekingU/rtdetr_r50vd) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplos: ```python >>> 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[[transformers.RTDetrResNetConfig]] #### transformers.RTDetrResNetConfig[[transformers.RTDetrResNetConfig]] ```python transformers.RTDetrResNetConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_channels: int = 3, embedding_size: int = 64, hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), depths: list[int] | tuple[int, ...] = (3, 4, 6, 3), layer_type: str = 'bottleneck', hidden_act: str = 'relu', downsample_in_first_stage: bool = False, downsample_in_bottleneck: bool = False, _out_features: list[str] | None = None, _out_indices: list[int] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/configuration_rt_detr_resnet.py#L25) **Parâmetros:** num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. embedding_size (`int`, *opcional*, padrão `64`) : Dimensionalidade dos embeddings e dos estados ocultos. hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(256, 512, 1024, 2048)`) : Dimensionalidade (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 usada, 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 reduzirá 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 fará o downsampling 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](https://huggingface.co/microsoft/resnet-50) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> 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[[transformers.RTDetrImageProcessor]] #### transformers.RTDetrImageProcessor[[transformers.RTDetrImageProcessor]] ```python transformers.RTDetrImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/image_processing_rt_detr.py#L131) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem 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 aplicar `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 redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `False`) : 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`) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding 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 preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida 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 centralizar o recorte da imagem. 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 for 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual 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 dos valores "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 caixas delimitadoras 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. #### preprocess[[transformers.RTDetrImageProcessor.preprocess]] ```python preprocess(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 = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/image_processing_rt_detr.py#L370) **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 estiver passando 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 deve converter a imagem 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 aplicar `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*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding 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 preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida 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 centralizar o recorte da imagem. 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 for 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual 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 dos valores "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 caixas delimitadoras 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[[transformers.RTDetrImageProcessor.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] = None, use_focal_loss: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/image_processing_rt_detr.py#L511) **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`, um sigmoid é aplicado 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 no lote, conforme previstos pelo modelo. Converte a saída bruta de [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) em caixas delimitadoras finais no formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Suporta apenas PyTorch. ## RTDetrImageProcessorPil[[transformers.RTDetrImageProcessorPil]] #### transformers.RTDetrImageProcessorPil[[transformers.RTDetrImageProcessorPil]] ```python transformers.RTDetrImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L130) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem 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 aplicar `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 redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `False`) : 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`) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding 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 preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida 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 centralizar o recorte da imagem. 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 for 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual 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 dos valores "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 caixas delimitadoras 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. #### preprocess[[transformers.RTDetrImageProcessorPil.preprocess]] ```python preprocess(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 = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L379) **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 estiver passando 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 deve converter a imagem 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 aplicar `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*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding 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 preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida 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 centralizar o recorte da imagem. 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 for 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual 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 dos valores "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 caixas delimitadoras 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[[transformers.RTDetrImageProcessorPil.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] = None, use_focal_loss: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/image_processing_pil_rt_detr.py#L507) **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`, um sigmoid é aplicado 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 no lote, conforme previstos pelo modelo. Converte a saída bruta de [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) em caixas delimitadoras finais no formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Suporta apenas PyTorch. ## RTDetrModel[[transformers.RTDetrModel]] #### transformers.RTDetrModel[[transformers.RTDetrModel]] ```python transformers.RTDetrModel(config: RTDetrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/modeling_rt_detr.py#L1424) **Parâmetros:** config ([RTDetrConfig](/docs/transformers/main/pt/model_doc/rt_detr#transformers.RTDetrConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.RTDetrModel.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/modeling_rt_detr.py#L1544) **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 obter detalhes (`processor_class` usa `image_processor_class` para processar 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 de máscara selecionados em `[0, 1]`: - 1 para pixels reais (ou seja, **não mascarados**), - 0 para pixels de preenchimento (ou seja, **mascarados**). [O que são máscaras de atenção?](../glossary#attention-mask) encoder_outputs (`torch.Tensor`, *opcional*) : 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 codificador. Usado na cross-attention do decodificador. 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]` of len `(batch_size,)`, *optional*) : Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes in the image,)` and the boxes a `torch.Tensor` of shape `(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`) compreendendo vários elementos dependendo da configuração (`None`) e das entradas. O método forward do [RTDetrModel](/docs/transformers/main/pt/model_doc/rt_detr#transformers.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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma 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` (uma para cada camada) de 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 encoder 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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, nas quais 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: ```python >>> 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[[transformers.RTDetrForObjectDetection]] #### transformers.RTDetrForObjectDetection[[transformers.RTDetrForObjectDetection]] ```python transformers.RTDetrForObjectDetection(config: RTDetrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/modeling_rt_detr.py#L1750) **Parâmetros:** config ([RTDetrConfig](/docs/transformers/main/pt/model_doc/rt_detr#transformers.RTDetrConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.RTDetrForObjectDetection.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/modeling_rt_detr.py#L1771) **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 obter detalhes (`processor_class` usa `image_processor_class` para processar 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 de máscara selecionados em `[0, 1]`: - 1 para pixels reais (ou seja, **não mascarados**), - 0 para pixels de preenchimento (ou seja, **mascarados**). [O que são máscaras de atenção?](../glossary#attention-mask) encoder_outputs (`torch.Tensor`, *opcional*) : 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 codificador. Usado na cross-attention do decodificador. 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]` of len `(batch_size,)`, *optional*) : Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes in the image,)` and the boxes a `torch.Tensor` of shape `(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](/docs/transformers/main/pt/model_doc/rt_detr#transformers.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 lote (ignorando possível padding). Você pode usar [post_process_object_detection()](/docs/transformers/main/pt/model_doc/rt_detr#transformers.RTDetrImageProcessor.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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma 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` (uma para cada camada) de 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 encoder 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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, nas quais 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: ```python >>> 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[[transformers.RTDetrResNetBackbone]] #### transformers.RTDetrResNetBackbone[[transformers.RTDetrResNetBackbone]] ```python transformers.RTDetrResNetBackbone(config: RTDetrResNetConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/modeling_rt_detr_resnet.py#L349) **Parâmetros:** config ([RTDetrResNetConfig](/docs/transformers/main/pt/model_doc/rt_detr#transformers.RTDetrResNetConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Backbone ResNet, para ser usado com frameworks como RTDETR. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.RTDetrResNetBackbone.forward]] ```python forward(pixel_values: Tensor, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/rt_detr/modeling_rt_detr_resnet.py#L362) **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 obter detalhes (`processor_class` usa `image_processor_class` para processar imagens). output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.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](/docs/transformers/main/pt/model_doc/rt_detr#transformers.RTDetrResNetConfig)) e das entradas. O método forward de [RTDetrResNetBackbone](/docs/transformers/main/pt/model_doc/rt_detr#transformers.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 a 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 nas cabeças de autoatenção. Exemplos: ```python >>> 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] ```