# DepthPro ## Visão geral O modelo DepthPro foi proposto em [Depth Pro: Sharp Monocular Metric Depth in Less Than a Second](https://huggingface.co/papers/2410.02073) por Aleksei Bochkovskii, Amaël Delaunoy, Hugo Germain, Marcel Santos, Yichao Zhou, Stephan R. Richter, Vladlen Koltun. O DepthPro é um modelo de fundação para estimativa métrica de profundidade monocular em zero-shot, projetado para gerar mapas de profundidade em alta resolução com nitidez notável e detalhes finos. Ele emprega uma arquitetura baseada em Vision Transformer (ViT) multi-escala, na qual as imagens são reduzidas, divididas em patches e processadas usando um codificador Dinov2 compartilhado. Os recursos de nível de patch extraídos são mesclados, ampliados e refinados usando um estágio de fusão semelhante ao DPT, permitindo uma estimativa precisa da profundidade. O resumo do artigo é o seguinte: *Apresentamos um modelo de fundação para estimativa métrica de profundidade monocular em zero-shot. Nosso modelo, Depth Pro, sintetiza mapas de profundidade em alta resolução com nitidez incomparável e detalhes de alta frequência. As previsões são métricas, com escala absoluta, sem depender da disponibilidade de metadados, como as intrínsecas da câmera. E o modelo é rápido, produzindo um mapa de profundidade de 2,25 megapixels em 0,3 segundos em uma GPU padrão. Essas características são viabilizadas por uma série de contribuições técnicas, incluindo um vision transformer multiescala eficiente para predição densa, um protocolo de treinamento que combina conjuntos de dados reais e sintéticos para alcançar alta precisão métrica ao mesmo tempo em que traça fronteiras finas, métricas de avaliação dedicadas para a precisão das fronteiras em mapas de profundidade estimados e estimativa de distância focal de estado da arte a partir de uma única imagem. Experimentos extensos analisam escolhas de design específicas e demonstram que o Depth Pro supera trabalhos anteriores em múltiplas dimensões.* drawing Saídas do DepthPro. Retirado do código oficial. Este modelo foi contribuído por [geetu040](https://github.com/geetu040). O código original pode ser encontrado [aqui](https://github.com/apple/ml-depth-pro). ## Dicas de uso O modelo DepthPro processa uma imagem de entrada primeiramente reduzindo sua resolução em múltiplas escalas e dividindo cada versão escalada em patches. Esses patches são então codificados usando um codificador de patches Dinov2 baseado em Vision Transformer (ViT) compartilhado, enquanto a imagem completa é processada por um codificador de imagem separado. Os recursos de patch extraídos são mesclados em mapas de recursos, ampliados e fundidos usando um decodificador semelhante ao DPT para gerar a estimativa final de profundidade. Se habilitado, um codificador adicional de Campo de Visão (FOV) processa a imagem para estimar o campo de visão da câmera, auxiliando na precisão da profundidade. ```python import requests import torch from PIL import Image from transformers import DepthProForDepthEstimation, DepthProImageProcessor url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) image_processor = DepthProImageProcessor.from_pretrained("apple/DepthPro-hf") model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", device_map="auto") inputs = image_processor(images=image, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) post_processed_output = image_processor.post_process_depth_estimation( outputs, target_sizes=[(image.height, image.width)], ) field_of_view = post_processed_output[0]["field_of_view"] focal_length = post_processed_output[0]["focal_length"] depth = post_processed_output[0]["predicted_depth"] depth = (depth - depth.min()) / depth.max() depth = depth * 255. depth = depth.detach().cpu().numpy() depth = Image.fromarray(depth.astype("uint8")) ``` ### Arquitetura e Configuração drawing Arquitetura do DepthPro. Retirada do artigo original. O modelo `DepthProForDepthEstimation` utiliza um `DepthProEncoder` para codificar a imagem de entrada e um `FeatureFusionStage` para fundir os recursos de saída do codificador. O `DepthProEncoder` utiliza, além disso, dois codificadores: - `patch_encoder` - A imagem de entrada é redimensionada com múltiplas proporções, conforme especificado na configuração `scaled_images_ratios`. - Cada imagem escalonada é dividida em **patches** menores de tamanho `patch_size`, com áreas de sobreposição determinadas por `scaled_images_overlap_ratios`. - Esses patches são processados pelo **`patch_encoder`** - `image_encoder` - A imagem de entrada também é redimensionada para `patch_size` e processada pelo **`image_encoder`** Ambos esses codificadores podem ser configurados por meio de `patch_model_config` e `image_model_config`, respectivamente, sendo ambos, por padrão, instâncias separadas de `Dinov2Model`. As saídas dos dois codificadores (`last_hidden_state`) e dos estados intermediários selecionados (`hidden_states`) de **`patch_encoder`** são fundidas por um `FeatureFusionStage` baseado em `DPT` para estimativa de profundidade. ### Previsão do Campo de Visão (FOV) A rede é complementada por uma cabeça de estimativa de distância focal. Uma pequena cabeça convolucional recebe recursos congelados da rede de estimativa de profundidade e recursos específicos da tarefa de um codificador de imagem ViT separado para prever o campo de visão angular horizontal. O parâmetro `use_fov_model` em `DepthProConfig` controla se a **previsão de FOV** está habilitada. Por padrão, ele é definido como `False` para economizar memória e computação. Quando habilitado, o **codificador de FOV** é instanciado com base no parâmetro `fov_model_config`, que por padrão é um `Dinov2Model`. O parâmetro `use_fov_model` também pode ser passado ao inicializar o modelo `DepthProForDepthEstimation`. O modelo pré-treinado no checkpoint `apple/DepthPro-hf` usa o codificador de FOV. Para usar o modelo pré-treinado sem o codificador de FOV, defina `use_fov_model=False` ao carregar o modelo, o que economiza computação. ```python from transformers import DepthProForDepthEstimation model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", use_fov_model=False, device_map="auto") ``` Para instanciar um novo modelo com codificador FOV, defina `use_fov_model=True` na configuração. ```python from transformers import DepthProConfig, DepthProForDepthEstimation config = DepthProConfig(use_fov_model=True) model = DepthProForDepthEstimation(config) ``` Ou defina `use_fov_model=True` ao inicializar o modelo, o que substitui o valor na configuração. ```python from transformers import DepthProConfig, DepthProForDepthEstimation config = DepthProConfig() model = DepthProForDepthEstimation(config, use_fov_model=True) ``` ### Usando Scaled Dot Product Attention (SDPA) O PyTorch inclui um operador nativo de atenção de produto escalar escalonado (SDPA) como parte de `torch.nn.functional`. Essa função abrange várias implementações que podem ser aplicadas dependendo das entradas e do hardware em uso. Consulte a [documentação oficial](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) ou a página [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) para mais informações. O SDPA é usado por padrão para `torch>=2.1.1` quando uma implementação está disponível, mas você também pode definir `attn_implementation="sdpa"` em `from_pretrained()` para solicitar explicitamente o uso do SDPA. ```python from transformers import DepthProForDepthEstimation model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", attn_implementation="sdpa", device_map="auto") ``` Para obter as melhores acelerações, recomendamos carregar o modelo em meia precisão (por exemplo, `torch.float16` ou `torch.bfloat16`). Em um benchmark local (A100-40GB, PyTorch 2.3.0, SO Ubuntu 22.04) com `float32` e o modelo `google/vit-base-patch16-224`, observamos os seguintes aumentos de velocidade durante a inferência. | Tamanho do lote | Tempo médio de inferência (ms), modo eager | Tempo médio de inferência (ms), modelo sdpa | Aceleração, Sdpa / Eager (x) | |--------------|-------------------------------------------|-------------------------------------------|------------------------------| | 1 | 7 | 6 | 1.17 | | 2 | 8 | 6 | 1.33 | | 4 | 8 | 6 | 1.33 | | 8 | 8 | 6 | 1.33 | ## Recursos Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o DepthPro: - Artigo de pesquisa: [Depth Pro: Sharp Monocular Metric Depth in Less Than a Second](https://huggingface.co/papers/2410.02073) - Implementação oficial: [apple/ml-depth-pro](https://github.com/apple/ml-depth-pro) - DepthPro Inference Notebook: [DepthPro Inference](https://github.com/qubvel/transformers-notebooks/blob/main/notebooks/DepthPro_inference.ipynb) - DepthPro para Super Resolução e Segmentação de Imagem - Leia o blog no Medium: [Depth Pro: Beyond Depth](https://medium.com/@raoarmaghanshakir040/depth-pro-beyond-depth-9d822fc557ba) - Código no Github: [geetu040/depthpro-beyond-depth](https://github.com/geetu040/depthpro-beyond-depth) Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente. ## DepthProConfig[[transformers.DepthProConfig]] #### transformers.DepthProConfig[[transformers.DepthProConfig]] ```python transformers.DepthProConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, fusion_hidden_size: int = 256, patch_size: int | list[int] | tuple[int, int] = 384, initializer_range: float = 0.02, intermediate_hook_ids: list[int] | tuple[int, ...] = (11, 5), intermediate_feature_dims: list[int] | tuple[int, ...] = (256, 256), scaled_images_ratios: list[int | float] | tuple[int | float, ...] = (0.25, 0.5, 1), scaled_images_overlap_ratios: list[float] | tuple[float, ...] = (0.0, 0.5, 0.25), scaled_images_feature_dims: list[int] | tuple[int, ...] = (1024, 1024, 512), merge_padding_value: int = 3, use_batch_norm_in_fusion_residual: bool = False, use_bias_in_fusion_residual: bool = True, use_fov_model: bool = False, num_fov_head_layers: int = 2, image_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, patch_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, fov_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/configuration_depth_pro.py#L28) **Parâmetros:** fusion_hidden_size (`int`, *opcional*, padrão 256) : O número de canais antes da fusão. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `384`) : O tamanho (resolução) de cada patch. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. intermediate_hook_ids (`list[int]`, *opcional*, padrão `[11, 5]`) : Índices dos estados ocultos intermediários do codificador de patches a serem usados para fusão. intermediate_feature_dims (`list[int]`, *opcional*, padrão `[256, 256]`) : Dimensões do estado oculto durante o upsampling para cada estado oculto intermediário em `intermediate_hook_ids`. scaled_images_ratios (`list[float]`, *opcional*, padrão `[0.25, 0.5, 1]`) : Proporções de imagens redimensionadas a serem usadas pelo codificador de patches. scaled_images_overlap_ratios (`list[float]`, *opcional*, padrão `[0.0, 0.5, 0.25]`) : Proporções de sobreposição entre patches para cada imagem escalada em `scaled_images_ratios`. scaled_images_feature_dims (`list[int]`, *opcional*, padrão `[1024, 1024, 512]`) : Dimensões do estado oculto durante o upsampling para cada imagem escalada em `scaled_images_ratios`. merge_padding_value (`int`, *opcional*, padrão 3) : Ao mesclar patches menores de volta ao tamanho da imagem, as seções sobrepostas desse tamanho são removidas. use_batch_norm_in_fusion_residual (`bool`, *opcional*, padrão `False`) : Se deve usar normalização de lote nas unidades residuais pré-ativação dos blocos de fusão. use_bias_in_fusion_residual (`bool`, *opcional*, padrão `True`) : Se deve usar viés nas unidades residuais pré-ativação dos blocos de fusão. use_fov_model (`bool`, *opcional*, padrão `False`) : Se deve usar `DepthProFovModel` para gerar o campo de visão. num_fov_head_layers (`int`, *opcional*, padrão 2) : Número de camadas de convolução na cabeça de `DepthProFovModel`. image_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *opcional*) : A configuração do modelo de codificador de imagem, que é carregada usando a API [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). Por padrão, o modelo Dinov2 é usado como backbone. patch_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *opcional*) : A configuração do modelo de codificador de patches, que é carregada usando a API [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). Por padrão, o modelo Dinov2 é usado como backbone. fov_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *opcional*) : A configuração do modelo de codificador de fov, que é carregada usando a API [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). Por padrão, o modelo Dinov2 é usado como backbone. Esta é a classe de configuração para armazenar a configuração de um DepthProModel. Ela é usada para instanciar um modelo Depth Pro 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 [apple/DepthPro](https://huggingface.co/apple/DepthPro) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import DepthProConfig, DepthProModel >>> # Initializing a DepthPro apple/DepthPro style configuration >>> configuration = DepthProConfig() >>> # Initializing a model (with random weights) from the apple/DepthPro style configuration >>> model = DepthProModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## DepthProImageProcessor[[transformers.DepthProImageProcessor]] #### transformers.DepthProImageProcessor[[transformers.DepthProImageProcessor]] ```python transformers.DepthProImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/image_processing_depth_pro.py#L45) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 1536, 'width': 1536}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após 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.5, 0.5, 0.5]`) : 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.5, 0.5, 0.5]`) : 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. 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. Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. -- Constrói um processador de imagem DepthPro. 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. #### preprocess[[transformers.DepthProImageProcessor.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']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **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`. image_like_kwargs (`dict[str, Any]`, *opcional*) : Sinalizador do desenvolvedor para entradas adicionais semelhantes a imagens que também serão pré-processadas. Use isso apenas se a passagem das entradas como kwarg não funcionar. Por exemplo, `preprocess(images, masks=masks)` é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos, `preprocess(images, image_like_inputs={"masks": masks})` pode ser usado em vez disso. 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. **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. Pré-processa uma imagem ou um lote de imagens. #### post_process_depth_estimation[[transformers.DepthProImageProcessor.post_process_depth_estimation]] ```python post_process_depth_estimation(outputs: DepthProDepthEstimatorOutput, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/image_processing_depth_pro.py#L84) Processa as previsões brutas de profundidade do modelo. ## DepthProModel[[transformers.DepthProModel]] #### transformers.DepthProModel[[transformers.DepthProModel]] ```python transformers.DepthProModel(config: DepthProConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L624) **Parâmetros:** config ([DepthProConfig](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProConfig)) : 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 Depth Pro básico, que produz estados ocultos brutos sem nenhum cabeçalho 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.DepthProModel.forward]] ```python forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L636) **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 [DepthProImageProcessor](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProImageProcessor). Veja [DepthProImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [DepthProImageProcessor](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProImageProcessor) para processar imagens). output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** `DepthProOutput` ou `tuple(torch.Tensor)` Um `DepthProOutput` 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 ([DepthProConfig](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProConfig)) e das entradas. O método forward do [DepthProModel](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProModel) 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, n_patches_per_batch, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **features** (`Union[torch.Tensor, List[torch.Tensor]]`, *opcional*) -- Recursos dos codificadores. Pode ser um único recurso ou uma lista de recursos. - **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 modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **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 após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplos: ```python >>> import torch >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, DepthProModel >>> url = "https://www.ilankelman.org/stopsigns/australia.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> checkpoint = "apple/DepthPro-hf" >>> processor = AutoProcessor.from_pretrained(checkpoint) >>> model = DepthProModel.from_pretrained(checkpoint) >>> # prepare image for the model >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.no_grad(): ... output = model(**inputs) >>> output.last_hidden_state.shape torch.Size([1, 35, 577, 1024]) ``` ## DepthProForDepthEstimation[[transformers.DepthProForDepthEstimation]] #### transformers.DepthProForDepthEstimation[[transformers.DepthProForDepthEstimation]] ```python transformers.DepthProForDepthEstimation(config: DepthProConfig, use_fov_model = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L995) **Parâmetros:** config ([DepthProConfig](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProConfig)) : 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. use_fov_model (`bool`, *opcional*) : Se deve usar o modelo de campo de visão. Modelo DepthPro com uma cabeça de estimativa de profundidade no topo (consistindo em 3 camadas convolucionais). 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.DepthProForDepthEstimation.forward]] ```python forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L1020) **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 [DepthProImageProcessor](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProImageProcessor). Veja [DepthProImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes (`processor_class` usa [DepthProImageProcessor](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProImageProcessor) para processar imagens). labels (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Mapas de estimativa de profundidade de verdade para o cálculo da perda. output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes. output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes. return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples. **Retorna:** `DepthProDepthEstimatorOutput` ou `tuple(torch.Tensor)` Um `DepthProDepthEstimatorOutput` 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 ([DepthProConfig](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProConfig)) e das entradas. O método forward de [DepthProForDepthEstimation](/docs/transformers/main/pt/model_doc/depth_pro#transformers.DepthProForDepthEstimation) 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` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1). - **predicted_depth** (`torch.Tensor` de forma `(batch_size, height, width)`, *opcional*) -- Profundidade prevista para cada pixel. - **field_of_view** (`torch.Tensor` de forma `(batch_size,)`, *opcional*, retornado quando `use_fov_model` é fornecido) -- Escalador de Campo de Visão. - **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 modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **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 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, DepthProForDepthEstimation >>> 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())) >>> checkpoint = "apple/DepthPro-hf" >>> processor = AutoImageProcessor.from_pretrained(checkpoint) >>> model = DepthProForDepthEstimation.from_pretrained(checkpoint) >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> model.to(device) >>> # prepare image for the model >>> inputs = processor(images=image, return_tensors="pt").to(device) >>> with torch.no_grad(): ... outputs = model(**inputs) >>> # interpolate to original size >>> post_processed_output = processor.post_process_depth_estimation( ... outputs, target_sizes=[(image.height, image.width)], ... ) >>> # get the field of view (fov) predictions >>> field_of_view = post_processed_output[0]["field_of_view"] >>> focal_length = post_processed_output[0]["focal_length"] >>> # visualize the prediction >>> predicted_depth = post_processed_output[0]["predicted_depth"] >>> depth = predicted_depth * 255 / predicted_depth.max() >>> depth = depth.detach().cpu().numpy() >>> depth = Image.fromarray(depth.astype("uint8")) ```