# DETR [DETR](https://huggingface.co/papers/2005.12872) consiste em um backbone convolucional seguido por um Transformer encoder-decoder que pode ser treinado de ponta a ponta para detecção de objetos. Ele simplifica significativamente grande parte da complexidade de modelos como Faster-R-CNN e Mask-R-CNN, que utilizam elementos como propostas de região, procedimento de supressão de máximos não máximos e geração de âncoras. Além disso, o DETR também pode ser estendido naturalmente para realizar segmentação panótica, simplesmente adicionando uma cabeça de máscara sobre as saídas do decoder. Você pode encontrar todos os checkpoints originais do DETR na organização [AI at Meta](https://huggingface.co/facebook/models?search=detr). > [!TIP] > Este modelo foi contribuído por [nielsr](https://huggingface.co/nielsr). > > Clique nos modelos DETR na barra lateral à direita para ver mais exemplos de como aplicar o DETR a diferentes tarefas de detecção de objetos e segmentação. > > Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais. O exemplo abaixo demonstra como realizar detecção de objetos com a classe [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) ou a classe [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). ```python from transformers import pipeline pipeline = pipeline( "object-detection", model="facebook/detr-resnet-50", device_map=0 ) pipeline("http://images.cocodataset.org/val2017/000000039769.jpg") ``` ```python import requests import torch from PIL import Image from transformers import AutoImageProcessor, AutoModelForObjectDetection url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(url, stream=True).raw) image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50") model = AutoModelForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto") # prepare image for the model 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.size[::-1]]), 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}") ``` Como o DETR funciona Aqui está um resumo explicando como o [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) funciona: Primeiro, uma imagem é enviada por meio de um backbone convolucional pré-treinado (no artigo, os autores utilizam ResNet-50/ResNet-101). Vamos supor que também adicionamos uma dimensão de lote. Isso significa que a entrada para o backbone é um tensor de forma `(batch_size, 3, height, width)`, assumindo que a imagem possui 3 canais de cor (RGB). O backbone CNN produz um novo mapa de recursos de menor resolução, tipicamente de forma `(batch_size, 2048, height/32, width/32)`. Em seguida, esse mapa é projetado para corresponder à dimensão oculta do Transformer do DETR, que é `256` por padrão, usando uma camada `nn.Conv2D`. Assim, agora temos um tensor de forma `(batch_size, 256, height/32, width/32).` A seguir, o mapa de recursos é achatado e transposto para obter um tensor de forma `(batch_size, seq_len, d_model)` = `(batch_size, width/32*height/32, 256)`. Portanto, uma diferença em relação aos modelos de NLP é que o comprimento da sequência é, na verdade, mais longo do que o habitual, mas com um `d_model` menor (que em NLP é tipicamente 768 ou superior). Em seguida, isso é enviado para o encoder, produzindo `encoder_hidden_states` com a mesma forma (você pode considerar esses como recursos da imagem). A seguir, os chamados **object queries** são enviados para o decoder. Trata-se de um tensor com a forma `(batch_size, num_queries, d_model)`, em que `num_queries` é tipicamente definido como 100 e inicializado com zeros. Esses embeddings de entrada são codificações posicionais aprendidas, às quais os autores se referem como object queries, e, de forma semelhante ao encoder, são somados à entrada de cada camada de atenção. Cada object query buscará um objeto específico na imagem. O decoder atualiza esses embeddings por meio de múltiplas camadas de autoatenção e de atenção encoder-decoder para produzir `decoder_hidden_states` com a mesma forma: `(batch_size, num_queries, d_model)`. A seguir, dois heads são adicionados no topo para detecção de objetos: uma camada linear para classificar cada object query em um dos objetos ou "no object", e um MLP para prever caixas delimitadoras para cada query. O modelo é treinado usando uma **perda de correspondência bipartida**: o que fazemos, na prática, é comparar as classes e as caixas delimitadoras previstas de cada uma das N = 100 consultas de objeto com as anotações de referência, preenchidas até o mesmo comprimento N (ou seja, se uma imagem contém apenas 4 objetos, 96 anotações terão apenas "sem objeto" como classe e "sem caixa delimitadora" como caixa delimitadora). O [algoritmo de correspondência húngara](https://en.wikipedia.org/wiki/Hungarian_algorithm) é usado para encontrar um mapeamento ótimo um-para-um de cada uma das N consultas para cada uma das N anotações. Em seguida, a entropia cruzada padrão (para as classes) e uma combinação linear da L1 e da [perda de IoU generalizada](https://giou.stanford.edu/) (para as caixas delimitadoras) são usadas para otimizar os parâmetros do modelo. O DETR pode ser naturalmente estendido para realizar segmentação panótica (que unifica a segmentação semântica e a segmentação de instâncias). [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) adiciona uma cabeça de máscara de segmentação sobre o [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection). A cabeça de máscara pode ser treinada de forma conjunta ou em um processo de duas etapas, no qual primeiro se treina um modelo [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) para detectar caixas delimitadoras ao redor tanto de "things" (instâncias) quanto de "stuff" (elementos de fundo, como árvores, estradas e céu), e então se congelam todos os pesos e treina-se apenas a cabeça de máscara por 25 épocas. Experimentalmente, essas duas abordagens produzem resultados semelhantes. Observe que a previsão de caixas é necessária para que o treinamento seja possível, pois o pareamento húngaro é calculado usando distâncias entre caixas. ## Observações - O DETR utiliza os chamados **object queries** para detectar objetos em uma imagem. O número de queries determina o número máximo de objetos que podem ser detectados em uma única imagem e é definido como 100 por padrão (veja o parâmetro `num_queries` de [DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig)). Observe que é bom ter alguma folga (no COCO, os autores usaram 100, enquanto o número máximo de objetos em uma imagem do COCO é ~70). - O decodificador do DETR atualiza os embeddings de consulta em paralelo. Isso difere de modelos de linguagem como o GPT-2, que utilizam decodificação autoregressiva em vez de paralela. Portanto, nenhuma máscara de atenção causal é utilizada. - O DETR adiciona embeddings de posição aos estados ocultos em cada camada de autoatenção e atenção cruzada antes de projetá-los em consultas e chaves. Para os embeddings de posição da imagem, é possível escolher entre embeddings de posição absolutos fixos sinusoidais ou aprendidos. Por padrão, o parâmetro `position_embedding_type` de [DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig) é definido como `"sine"`. - Durante o treinamento, os autores do DETR constataram que era útil usar perdas auxiliares no decodificador, especialmente para ajudar o modelo a produzir o número correto de objetos de cada classe. Se você definir o parâmetro `auxiliary_loss` de [DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig) como `True`, redes neurais feedforward de previsão e perdas húngaras são adicionadas após cada camada do decodificador (com os FFNs compartilhando parâmetros). - Se você deseja treinar o modelo em um ambiente distribuído entre vários nós, é necessário atualizar a variável *num_boxes* na classe *DetrLoss* do arquivo *modeling_detr.py*. Ao treinar em vários nós, esse valor deve ser definido como o número médio de caixas de alvo entre todos os nós, conforme pode ser visto na implementação original [aqui](https://github.com/facebookresearch/detr/blob/a54b77800eb8e64e3ad0d8237789fcbf2f8350c5/models/detr.py#L227-L232). - [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) e [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) podem ser inicializados com qualquer backbone convolucional disponível na [biblioteca timm](https://github.com/rwightman/pytorch-image-models). Por exemplo, para inicializar com um backbone MobileNet, basta definir o atributo `backbone` de [DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig) como `"tf_mobilenetv3_small_075"` e, em seguida, inicializar o modelo com essa configuração. - O DETR redimensiona as imagens de entrada de modo que o lado mais curto tenha pelo menos uma certa quantidade de pixels, enquanto o lado mais longo tenha no máximo 1333 pixels. Durante o treinamento, é usada a escala de aumento (scale augmentation), de modo que o lado mais curto é definido aleatoriamente para ter pelo menos 480 e no máximo 800 pixels. Durante a inferência, o lado mais curto é definido como 800. É possível usar [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor) para preparar as imagens (e anotações opcionais no formato COCO) para o modelo. Devido a esse redimensionamento, as imagens em um lote podem ter tamanhos diferentes. O DETR resolve isso preenchendo as imagens até o maior tamanho do lote e criando uma máscara de pixels que indica quais pixels são reais e quais são preenchimento. Alternativamente, também é possível definir uma `collate_fn` personalizada para agrupar as imagens em lotes, usando `~transformers.DetrImageProcessor.pad_and_create_pixel_mask`. - O tamanho das imagens determinará a quantidade de memória utilizada e, portanto, o `batch_size`. Recomenda-se usar um tamanho de lote de 2 por GPU. Consulte [este thread no Github](https://github.com/facebookresearch/detr/issues/150) para mais informações. Existem outras três maneiras de instanciar um modelo DETR (dependendo da sua preferência): - Opção 1: Instanciar o DETR com pesos pré-treinados para o modelo inteiro ```python from transformers import DetrForObjectDetection model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto") ``` - Opção 2: Instanciar o DETR com pesos inicializados aleatoriamente para o Transformer, mas com pesos pré-treinados para o backbone ```python from transformers import DetrConfig, DetrForObjectDetection config = DetrConfig() model = DetrForObjectDetection(config) ``` - Opção 3: Instanciar o DETR com pesos inicializados aleatoriamente para o backbone + Transformer ```python config = DetrConfig() model = DetrForObjectDetection(config) ``` Como resumo, considere a seguinte tabela: | Tarefa | Detecção de objetos | Segmentação de instâncias | Segmentação panótica | |------|------------------|-----------------------|-----------------------| | **Descrição** | Previsão de caixas delimitadoras e rótulos de classes ao redor de objetos em uma imagem | Prever máscaras ao redor de objetos (ou seja, instâncias) em uma imagem | Prever máscaras em torno de ambos os objetos (ou seja, instâncias) e também "stuff" (ou seja, elementos de fundo como árvores e estradas) em uma imagem | | **Modelo** | [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) | [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) | [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) | | **Conjunto de dados de exemplo** | Detecção COCO | Detecção COCO, panóptico COCO | COCO panótico | | **Formato das anotações a serem fornecidas para** [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor) | {'image_id': `int`, 'annotations': `list[Dict]`} cada Dict sendo uma anotação de objeto COCO | {'image_id': `int`, 'annotations': `list[Dict]`} (no caso de detecção COCO) ou {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`} (no caso de panóptico COCO) | {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`} e masks_path (caminho para o diretório contendo os arquivos PNG das máscaras) | | **Processamento pós** (ou seja, converter a saída do modelo para o formato Pascal VOC) | `~transformers.DetrImageProcessor.post_process` | `~transformers.DetrImageProcessor.post_process_segmentation` | `~transformers.DetrImageProcessor.post_process_segmentation`, `~transformers.DetrImageProcessor.post_process_panoptic` | | **avaliadores** | `CocoEvaluator` com `iou_types="bbox"` | `CocoEvaluator` com `iou_types="bbox"` ou `"segm"` | `CocoEvaluator` com `iou_types="bbox"` ou `"segm"`, `PanopticEvaluator` | - Em resumo, os dados devem ser preparados no formato de detecção COCO ou no formato panótico COCO. Em seguida, utilize [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor) para criar `pixel_values`, `pixel_mask` e, opcionalmente, `labels`, que podem ser usados para treinar (ou ajustar finamente) um modelo. - Para a avaliação, primeiro é necessário converter as saídas do modelo usando um dos métodos de pós-processamento de [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor). Esses resultados podem ser fornecidos para `CocoEvaluator` ou `PanopticEvaluator`, que permitem calcular métricas como mean Average Precision (mAP) e Panoptic Quality (PQ). Os últimos objetos são implementados no [repositório original](https://github.com/facebookresearch/detr). Consulte os [notebooks de exemplo](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR) para mais informações sobre a avaliação. ## Recursos - Consulte estes [notebooks](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR) para exemplos de ajuste fino de [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) e [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em um conjunto de dados personalizado. ## DetrConfig[[transformers.DetrConfig]] #### transformers.DetrConfig[[transformers.DetrConfig]] ```python transformers.DetrConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_channels: int = 3, num_queries: int = 100, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', dilation: bool = False, class_cost: int = 1, bbox_cost: int = 5, giou_cost: int = 2, mask_loss_coefficient: int = 1, dice_loss_coefficient: int = 1, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, eos_coefficient: float = 0.1) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/configuration_detr.py#L25) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não. backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. num_queries (`int`, *opcional*, padrão 100) : Número de consultas de objeto, ou seja, slots de detecção. Este é o número máximo de objetos que o [ConditionalDetrModel](/docs/transformers/main/pt/model_doc/conditional_detr#transformers.ConditionalDetrModel) pode detectar em uma única imagem. Para o COCO, recomendamos 100 consultas. encoder_layers (`int`, *opcional*, padrão `6`) : 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 `2048`) : 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. 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_ffn_dim (`int`, *opcional*, padrão `2048`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador. 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. encoder_layerdrop (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de LayerDrop para o codificador. Consulte o [artigo LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes. decoder_layerdrop (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de LayerDrop para o decodificador. Consulte o [artigo LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes. activation_function (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. d_model (`int`, *opcional*, padrão `256`) : Tamanho das camadas do codificador e da camada pooler. dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. activation_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as ativações dentro da camada totalmente conectada. init_std (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. init_xavier_std (`float`, *opcional*, padrão `1.0`) : O fator de escala usado na inicialização Xavier dos pesos de atenção cruzada. auxiliary_loss (`bool`, *opcional*, padrão `False`) : Se as perdas de decodificação auxiliares (perdas em cada camada do decodificador) devem ser usadas. position_embedding_type (`str`, *opcional*, padrão `"sine"`) : Tipo de embeddings de posição a ser usado sobre os recursos da imagem. Um dos valores `"sine"` ou `"learned"`. dilation (`bool`, *opcional*, padrão `False`) : Se deve substituir o stride pela dilatação no último bloco convolucional (DC5). Suportado apenas quando `use_timm_backbone` = `True`. class_cost (`int`, *opcional*, padrão `1`) : Peso relativo do erro de classificação no custo de correspondência húngara. bbox_cost (`int`, *opcional*, padrão `5`) : Peso relativo do erro L1 da caixa delimitadora no custo de correspondência húngara. giou_cost (`int`, *opcional*, padrão `2`) : Peso relativo da perda de IoU generalizada no custo de correspondência húngara. mask_loss_coefficient (`int`, *opcional*, padrão `1`) : Peso relativo da focal loss na perda de segmentação panótica. dice_loss_coefficient (`int`, *opcional*, padrão `1`) : Peso relativo da perda dice na perda de segmentação panótica. bbox_loss_coefficient (`int`, *opcional*, padrão `5`) : Peso relativo da perda de caixa delimitadora L1 na perda de segmentação panótica. giou_loss_coefficient (`int`, *opcional*, padrão `2`) : Peso relativo da perda de IoU generalizada na perda de segmentação panótica. eos_coefficient (`float`, *opcional*, padrão `0.1`) : 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 DetrModel. Ela é usada para instanciar um modelo 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 [facebook/detr-resnet-50](https://huggingface.co/facebook/detr-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. Exemplos: ```python >>> from transformers import DetrConfig, DetrModel >>> # Initializing a DETR facebook/detr-resnet-50 style configuration >>> configuration = DetrConfig() >>> # Initializing a model (with random weights) from the facebook/detr-resnet-50 style configuration >>> model = DetrModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## DetrImageProcessor[[transformers.DetrImageProcessor]] #### transformers.DetrImageProcessor[[transformers.DetrImageProcessor]] ```python transformers.DetrImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L426) **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 `{'shortest_edge' : 800, 'longest_edge': 1333}`): 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 `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.485, 0.456, 0.406]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.229, 0.224, 0.225]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `True`) : 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 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 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 DetrImageProcessor. #### preprocess[[transformers.DetrImageProcessor.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/detr/image_processing_detr.py#L681) **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 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[[transformers.DetrImageProcessor.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L823) **Parâmetros:** outputs (`DetrObjectDetectionOutput`) : Saídas brutas do modelo. threshold (`float`, *opcional*) : 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. **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. #### post_process_semantic_segmentation[[transformers.DetrImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L876) **Parâmetros:** outputs ([DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation)) : Saídas brutas do modelo. target_sizes (`list[tuple[int, int]]`, *opcional*) : Uma lista de tuplas (`tuple[int, int]`) contendo o tamanho alvo (altura, largura) de cada imagem no lote. Se não definido, as previsões não serão redimensionadas. return_segmentation_scores (`bool`, *opcional*, padrão `False`) : Se deve retornar as pontuações de segmentação junto com o mapa de segmentação. Quando `True`, cada elemento da lista retornada é um `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). **Retorna:** `list[torch.Tensor]` ou `list[SemanticSegmentationPostProcessorOutput]` Quando `return_segmentation_scores=False` (padrão), uma lista de comprimento `batch_size` em que cada item é um mapa de segmentação de forma `(height, width)` com IDs de classe. Quando `return_segmentation_scores=True`, uma lista de `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). Em ambos os casos, `(height, width)` corresponde ao tamanho alvo (se `target_sizes` for especificado). Converte a saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em mapas de segmentação semântica. Suporta apenas PyTorch. #### post_process_instance_segmentation[[transformers.DetrImageProcessor.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L947) **Parâmetros:** outputs ([DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation)) : Saídas brutas do modelo. threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. target_sizes (`list[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão. Se não definido, as previsões não serão redimensionadas. return_coco_annotation (`bool`, *opcional*) : O valor padrão é `False`. Se definido como `True`, os mapas de segmentação são retornados no formato de codificação por comprimento de execução (RLE) do COCO. **Retorna:** `list[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- Um tensor de forma `(height, width)` em que cada pixel representa um `segment_id` ou `list[List]` codificação por comprimento de execução (RLE) do mapa de segmentação, se return_coco_annotation estiver definido como `True`. Definido como `None` se nenhuma máscara for encontrada acima de `threshold`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- Um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em previsões de segmentação de instância. Suporta apenas PyTorch. #### post_process_panoptic_segmentation[[transformers.DetrImageProcessor.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L1030) **Parâmetros:** outputs ([DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation)) : As saídas de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation). threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. label_ids_to_fuse (`Set[int]`, *opcional*) : Os rótulos neste estado terão todas as suas instâncias fundidas. Por exemplo, poderíamos dizer que pode haver apenas um céu em uma imagem, mas várias pessoas, então o ID do rótulo para céu estaria nesse conjunto, mas não o de pessoa. target_sizes (`list[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão no lote. Se não definido, as previsões não serão redimensionadas. **Retorna:** `list[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- um tensor de forma `(height, width)` em que cada pixel representa um `segment_id` ou `None` caso nenhuma máscara seja encontrada acima de `threshold`. Se `target_sizes` for especificado, a segmentation é redimensionada para a entrada correspondente de `target_sizes`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **was_fused** -- um booleano, `True` se `label_id` estava em `label_ids_to_fuse`, `False` caso contrário. Múltiplas instâncias da mesma classe / rótulo foram fundidas e atribuídas a um único `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em previsões de segmentação panótica de imagem. Suporta apenas PyTorch. ## DetrImageProcessorPil[[transformers.DetrImageProcessorPil]] #### transformers.DetrImageProcessorPil[[transformers.DetrImageProcessorPil]] ```python transformers.DetrImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L432) **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 `{'shortest_edge' : 800, 'longest_edge': 1333}`): 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 `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.485, 0.456, 0.406]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.229, 0.224, 0.225]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*, padrão `True`) : 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 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 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 DetrImageProcessor. #### preprocess[[transformers.DetrImageProcessorPil.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/detr/image_processing_pil_detr.py#L700) **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 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[[transformers.DetrImageProcessorPil.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L845) **Parâmetros:** outputs (`DetrObjectDetectionOutput`) : Saídas brutas do modelo. threshold (`float`, *opcional*) : 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. **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. #### post_process_semantic_segmentation[[transformers.DetrImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L899) **Parâmetros:** outputs ([DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation)) : Saídas brutas do modelo. target_sizes (`list[tuple[int, int]]`, *opcional*) : Uma lista de tuplas (`tuple[int, int]`) contendo o tamanho alvo (altura, largura) de cada imagem no lote. Se não definido, as previsões não serão redimensionadas. return_segmentation_scores (`bool`, *opcional*, padrão `False`) : Se deve retornar as pontuações de segmentação junto com o mapa de segmentação. Quando `True`, cada elemento da lista retornada é um `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). **Retorna:** `list[torch.Tensor]` ou `list[SemanticSegmentationPostProcessorOutput]` Quando `return_segmentation_scores=False` (padrão), uma lista de comprimento `batch_size` em que cada item é um mapa de segmentação de forma `(height, width)` com IDs de classe. Quando `return_segmentation_scores=True`, uma lista de `SemanticSegmentationPostProcessorOutput` com os campos `segmentation` (IDs de classe, forma `(height, width)`) e `segmentation_scores` (forma `(num_classes, height, width)`). Em ambos os casos, `(height, width)` corresponde ao tamanho alvo (se `target_sizes` for especificado). Converte a saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em mapas de segmentação semântica. Suporta apenas PyTorch. #### post_process_instance_segmentation[[transformers.DetrImageProcessorPil.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L971) **Parâmetros:** outputs ([DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation)) : Saídas brutas do modelo. threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. target_sizes (`list[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão. Se não definido, as previsões não serão redimensionadas. return_coco_annotation (`bool`, *opcional*) : O valor padrão é `False`. Se definido como `True`, os mapas de segmentação são retornados no formato de codificação por comprimento de execução (RLE) do COCO. **Retorna:** `list[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- Um tensor de forma `(height, width)` em que cada pixel representa um `segment_id` ou `list[List]` codificação por comprimento de execução (RLE) do mapa de segmentação, se return_coco_annotation estiver definido como `True`. Definido como `None` se nenhuma máscara for encontrada acima de `threshold`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- Um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em previsões de segmentação de instância. Suporta apenas PyTorch. #### post_process_panoptic_segmentation[[transformers.DetrImageProcessorPil.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L1055) **Parâmetros:** outputs ([DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation)) : As saídas de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation). threshold (`float`, *opcional*, padrão 0.5) : O limiar de probabilidade para manter as máscaras de instâncias previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.8) : O limiar da área da máscara de sobreposição para mesclar ou descartar pequenas partes desconectadas dentro de cada máscara de instância binária. label_ids_to_fuse (`Set[int]`, *opcional*) : Os rótulos neste estado terão todas as suas instâncias fundidas. Por exemplo, poderíamos dizer que pode haver apenas um céu em uma imagem, mas várias pessoas, então o ID do rótulo para céu estaria nesse conjunto, mas não o de pessoa. target_sizes (`list[Tuple]`, *opcional*) : Lista de comprimento (batch_size), em que cada item da lista (`tuple[int, int]]`) corresponde ao tamanho final solicitado (altura, largura) de cada previsão no lote. Se não definido, as previsões não serão redimensionadas. **Retorna:** `list[Dict]` Uma lista de dicionários, um por imagem, cada dicionário contendo duas chaves: - **segmentation** -- um tensor de forma `(height, width)` em que cada pixel representa um `segment_id` ou `None` caso nenhuma máscara seja encontrada acima de `threshold`. Se `target_sizes` for especificado, a segmentation é redimensionada para a entrada correspondente de `target_sizes`. - **segments_info** -- Um dicionário que contém informações adicionais sobre cada segmento. - **id** -- um inteiro que representa o `segment_id`. - **label_id** -- Um inteiro que representa o id da rótulo/classe semântica correspondente a `segment_id`. - **was_fused** -- um booleano, `True` se `label_id` estava em `label_ids_to_fuse`, `False` caso contrário. Múltiplas instâncias da mesma classe / rótulo foram fundidas e atribuídas a um único `segment_id`. - **score** -- Pontuação de previsão do segmento com `segment_id`. Converte a saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) em previsões de segmentação panótica de imagem. Suporta apenas PyTorch. ## Saídas específicas do DETR[[transformers.models.detr.modeling_detr.DetrModelOutput]] #### transformers.models.detr.modeling_detr.DetrModelOutput[[transformers.models.detr.modeling_detr.DetrModelOutput]] ```python transformers.models.detr.modeling_detr.DetrModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, intermediate_hidden_states: typing.Optional[torch.Tensor] = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L76) **Parâmetros:** last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Sequência de hidden-states na saída da última camada do decoder do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, de forma `(batch_size, 1, hidden_size)`, é retornado. past_key_values (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) : Trata-se de uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache de kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. 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) com a forma `(batch_size, sequence_length, hidden_size)`. Hidden-states do decoder na saída de cada camada, além das saídas opcionais dos embeddings iniciais. 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 a 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 nos cabeçalhos 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 a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de cross-attention do decoder, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states 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` (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)`. Hidden-states do encoder na saída de cada camada, além das saídas iniciais opcionais dos embeddings. 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 a 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 nos cabeçalhos de autoatenção. intermediate_hidden_states (`torch.Tensor` de forma `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *opcional*, retornado quando `config.auxiliary_loss=True`) : Ativações intermediárias do decodificador, ou seja, a saída de cada camada do decodificador, cada uma delas passando por um layernorm. Classe base para as saídas do modelo encoder-decoder DETR. Esta classe adiciona um atributo ao Seq2SeqModelOutput, a saber, uma pilha opcional de ativações intermediárias do decoder, ou seja, a saída de cada camada do decoder, cada uma delas submetida a um layernorm. Isso é útil ao treinar o modelo com perdas de decodificação auxiliares. #### transformers.models.detr.modeling_detr.DetrObjectDetectionOutput[[transformers.models.detr.modeling_detr.DetrObjectDetectionOutput]] ```python transformers.models.detr.modeling_detr.DetrObjectDetectionOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L92) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` são fornecidos)) : 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 consultas, 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 o preenchimento possível). Você pode usar [post_process_object_detection()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) para recuperar as caixas delimitadoras não normalizadas. auxiliary_outputs (`list[Dict]`, *opcional*) : Opcional, retornado apenas quando as perdas auxiliares estã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, sequence_length, hidden_size)`, *opcional*) : Sequência de estados ocultos na saída da última camada do decodificador do modelo. 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 iniciais dos embeddings. 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 a 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 nos cabeçalhos 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 a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states 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` (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 iniciais dos embeddings. 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 a 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 nos cabeçalhos de autoatenção. Tipo de saída de [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection). #### transformers.models.detr.modeling_detr.DetrSegmentationOutput[[transformers.models.detr.modeling_detr.DetrSegmentationOutput]] ```python transformers.models.detr.modeling_detr.DetrSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, pred_masks: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L135) **Parâmetros:** loss (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` são fornecidos)) : 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 consultas, 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 o preenchimento possível). Você pode usar [post_process_object_detection()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) para recuperar as caixas delimitadoras não normalizadas. pred_masks (`torch.Tensor` de forma `(batch_size, num_queries, height/4, width/4)`) : Logits das máscaras de segmentação para todas as queries. Consulte também [post_process_semantic_segmentation()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation) [post_process_panoptic_segmentation()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation) para avaliar as máscaras de segmentação semântica, de instância e panóptica, respectivamente. auxiliary_outputs (`list[Dict]`, *opcional*) : Opcional, retornado apenas quando as perdas auxiliares estã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, sequence_length, hidden_size)`, *opcional*) : Sequência de estados ocultos na saída da última camada do decodificador do modelo. 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 iniciais dos embeddings. 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 a 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 nos cabeçalhos 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 a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de cross-attention. encoder_last_hidden_state (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states 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` (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 iniciais dos embeddings. 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 a 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 nos cabeçalhos de autoatenção. Tipo de saída de [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation). ## DetrModel[[transformers.DetrModel]] #### transformers.DetrModel[[transformers.DetrModel]] ```python transformers.DetrModel(config: DetrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1115) **Parâmetros:** config ([DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo DETR básico (consistindo de um backbone e um Transformer encoder-decoder) que produz estados ocultos brutos, sem nenhum head específico 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.DetrModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1144) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensors 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 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) decoder_attention_mask (`torch.Tensor` de forma `(batch_size, num_queries)`, *opcional*) : Máscara para evitar a execução de atenção em determinadas consultas de objeto no decodificador. Valores de máscara selecionados em `[0, 1]`: - 1 para consultas que **não estão mascaradas**, - 0 para consultas que **estão mascaradas**. 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. Útil para contornar o backbone de visão. decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, num_queries, hidden_size)`, *opcional*) : Opcionalmente, em vez de inicializar as consultas com um tensor de zeros, você pode escolher passar diretamente uma representação incorporada. Útil para tarefas que exigem inicialização personalizada de consultas. **Retorna:** [DetrModelOutput](/docs/transformers/main/pt/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) ou `tuple(torch.Tensor)` Um [DetrModelOutput](/docs/transformers/main/pt/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) 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 [DetrModel](/docs/transformers/main/pt/model_doc/detr#transformers.DetrModel) 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, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do decoder do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **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 opcionais 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 opcionais 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. - **intermediate_hidden_states** (`torch.Tensor` de forma `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *opcional*, retornado quando `config.auxiliary_loss=True`) -- Ativações intermediárias do decodificador, ou seja, a saída de cada camada do decodificador, cada uma delas passando por um layernorm. Exemplos: ```python >>> from transformers import AutoImageProcessor, DetrModel >>> 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("facebook/detr-resnet-50") >>> model = DetrModel.from_pretrained("facebook/detr-resnet-50") >>> # prepare image for the model >>> inputs = image_processor(images=image, return_tensors="pt") >>> # forward pass >>> outputs = model(**inputs) >>> # the last hidden states are the final query embeddings of the Transformer decoder >>> # these are of shape (batch_size, num_queries, hidden_size) >>> last_hidden_states = outputs.last_hidden_state >>> list(last_hidden_states.shape) [1, 100, 256] ``` ## DetrForObjectDetection[[transformers.DetrForObjectDetection]] #### transformers.DetrForObjectDetection[[transformers.DetrForObjectDetection]] ```python transformers.DetrForObjectDetection(config: DetrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1309) **Parâmetros:** config ([DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Modelo DETR (composto por um backbone e um Transformer encoder-decoder) com cabeças de detecção de objetos no topo, para tarefas como a detecção COCO. 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.DetrForObjectDetection.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1327) **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) decoder_attention_mask (`torch.Tensor` de forma `(batch_size, num_queries)`, *opcional*) : Máscara para evitar a execução de atenção em determinadas consultas de objeto no decodificador. Valores de máscara selecionados em `[0, 1]`: - 1 para consultas que **não estão mascaradas**, - 0 para consultas que **estão mascaradas**. 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. Útil para contornar o backbone de visão. decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, num_queries, hidden_size)`, *opcional*) : Opcionalmente, em vez de inicializar as consultas com um tensor de zeros, você pode escolher passar diretamente uma representação incorporada. Útil para tarefas que exigem inicialização personalizada de consultas. 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:** [DetrObjectDetectionOutput](/docs/transformers/main/pt/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) ou `tuple(torch.Tensor)` Um [DetrObjectDetectionOutput](/docs/transformers/main/pt/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) 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 [DetrForObjectDetection](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForObjectDetection) 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/detr#transformers.DetrImageProcessor.post_process_object_detection) para recuperar as caixas delimitadoras não normalizadas. - **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, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do decodificador do modelo. - **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. Exemplos: ```python >>> from transformers import AutoImageProcessor, DetrForObjectDetection >>> import torch >>> 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("facebook/detr-resnet-50") >>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> # 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 remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98] Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66] Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76] Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93] Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72] ``` ## DetrForSegmentation[[transformers.DetrForSegmentation]] #### transformers.DetrForSegmentation[[transformers.DetrForSegmentation]] ```python transformers.DetrForSegmentation(config: DetrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1441) **Parâmetros:** config ([DetrConfig](/docs/transformers/main/pt/model_doc/detr#transformers.DetrConfig)) : 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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Modelo DETR (composto por um backbone e um Transformer encoder-decoder) com uma cabeça de segmentação no topo, para tarefas como panoptic do COCO. 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.DetrForSegmentation.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1463) **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) decoder_attention_mask (`torch.Tensor` de forma `(batch_size, num_queries)`, *opcional*) : Máscara para evitar a execução de atenção em determinadas consultas de objeto no decodificador. Valores de máscara selecionados em `[0, 1]`: - 1 para consultas que **não estão mascaradas**, - 0 para consultas que **estão mascaradas**. 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*) : Mantido para compatibilidade reversa, mas não pode ser usado para segmentação, pois a segmentação requer recursos multiescala do backbone que não estão disponíveis ao contorná-lo com inputs_embeds. decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, num_queries, hidden_size)`, *opcional*) : Opcionalmente, em vez de inicializar as consultas com um tensor de zeros, você pode escolher passar diretamente uma representação incorporada. Útil para tarefas que exigem inicialização personalizada de consultas. labels (`list[Dict]` of len `(batch_size,)`, *optional*) : Labels for computing the bipartite matching loss, DICE/F-1 loss and Focal loss. List of dicts, each dictionary containing at least the following 3 keys: 'class_labels', 'boxes' and 'masks' (the class labels, bounding boxes and segmentation masks 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,)`, the boxes a `torch.Tensor` of shape `(number of bounding boxes in the image, 4)` and the masks a `torch.Tensor` of shape `(number of bounding boxes in the image, height, width)`. **Retorna:** [DetrSegmentationOutput](/docs/transformers/main/pt/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) ou `tuple(torch.Tensor)` Um [DetrSegmentationOutput](/docs/transformers/main/pt/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) 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 [DetrForSegmentation](/docs/transformers/main/pt/model_doc/detr#transformers.DetrForSegmentation) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` 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/detr#transformers.DetrImageProcessor.post_process_object_detection) para recuperar as caixas delimitadoras não normalizadas. - **pred_masks** (`torch.Tensor` de forma `(batch_size, num_queries, height/4, width/4)`) -- Logits das máscaras de segmentação para todas as queries. Consulte também [post_process_semantic_segmentation()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) ou [post_process_instance_segmentation()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation) [post_process_panoptic_segmentation()](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation) para avaliar máscaras de segmentação semântica, de instância e panóptica, respectivamente. - **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, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do decodificador do modelo. - **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. Exemplos: ```python >>> import io >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from PIL import Image >>> import torch >>> import numpy >>> from transformers import AutoImageProcessor, DetrForSegmentation >>> from transformers.image_transforms import rgb_to_id >>> 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("facebook/detr-resnet-50-panoptic") >>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic") >>> # prepare image for the model >>> inputs = image_processor(images=image, return_tensors="pt") >>> # forward pass >>> outputs = model(**inputs) >>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps >>> # Segmentation results are returned as a list of dictionaries >>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)]) >>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found >>> panoptic_seg = result[0]["segmentation"] >>> panoptic_seg.shape torch.Size([300, 500]) >>> # Get prediction score and segment_id to class_id mapping of each segment >>> panoptic_segments_info = result[0]["segments_info"] >>> len(panoptic_segments_info) 5 ```