Hugging Face's logo

Transformers documentation

TIPSv2 DPT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado no HF papers em 13/04/2026 e contribuído para o Hugging Face Transformers em 06/07/2026.

TIPSv2 DPT

FlashAttention SDPA

Visão geral

TIPSv2 com uma cabeça de transformador de predição densa (DPT); consulte a documentação do TIPSv2 para mais informações.

tipsv2 architecture overview

Este modelo foi contribuído por guarin. O código original pode ser encontrado aqui.

Você pode encontrar todos os checkpoints originais do TIPSv2 DPT na coleção TIPSv2.

Veja TIPSv2 para os backbones de visão e linguagem do TIPSv2, bem como para a classificação de imagens zero shot.

Pipeline
Previsão densa
Estimativa de profundidade
Estimação normal
Segmentação semântica
from transformers import pipeline

pipe = pipeline(task="depth-estimation", model="google/tipsv2-b14-dpt", device_map="auto")
out = pipe("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")
out["depth"]  # PIL Image normalized to [min, max] of predicted_depth

# Visualization
import matplotlib.pyplot as plt
from transformers.image_utils import load_image

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")

figure, axes = plt.subplots(1, 2, figsize=(10, 5))
axes[0].imshow(image)
axes[1].imshow(out["depth"])
axes[1].set_title("Depth")
for axis in axes:
    axis.axis("off")
plt.show()
tipsv2 depth estimation pipeline 
from transformers import pipeline

pipe = pipeline(task="image-segmentation", model="google/tipsv2-b14-dpt", device_map="auto")
out = pipe("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")
out[0]["label"] # string class label
out[0]["mask"]  # PIL Image with binary mask set to class id

# Visualization
import matplotlib.pyplot as plt
from transformers.image_utils import load_image

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")

figure, axes = plt.subplots(1, 2, figsize=(10, 5))
axes[0].imshow(image)
axes[1].imshow(out[0]["mask"], cmap="gray")
axes[1].set_title(out[0]["label"])
for axis in axes:
    axis.axis("off")
plt.show()
tipsv2 image segmentation pipeline

Observações

Dicasv2DptConfig

classe transformers.Tipsv2DptConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneneck_hidden_sizes: list[int] | tuple[int, ...] | None = Nonefusion_hidden_size: int = 256reassemble_factors: list[int | float] | tuple[int | float, ...] | None = Nonereadout_activation: str = 'gelu_pytorch_tanh'num_depth_bins: int = 256min_depth: float = 0.001max_depth: float = 10.0depth_decoder_activation: str = 'relu'semantic_loss_ignore_index: int = 255 )

Parâmetros

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — A configuração do modelo backbone.
  • neck_hidden_sizes (list[int], opcional, padrão [96, 192, 384, 768]) — Os tamanhos ocultos para projetar os mapas de características do backbone.
  • fusion_hidden_size (int, opcional, padrão 256) — O número de canais antes da fusão.
  • reassemble_factors (list[float], opcional, padrão [4, 2, 1, 0.5]) — Fatores de up/downsampling das camadas de reassemble.
  • readout_activation (str, opcional, padrão "gelu_pytorch_tanh") — Ativação aplicada após a camada de projeção de readout.
  • num_depth_bins (int, opcional, padrão 256) — O número de bins de profundidade usados pela cabeça de estimativa de profundidade.
  • min_depth (float, opcional, padrão 0.001) — O valor mínimo de profundidade (em metros) para o cálculo dos bins de profundidade.
  • max_depth (float, opcional, padrão 10.0) — O valor de profundidade máxima (em metros) para o cálculo dos bins de profundidade.
  • depth_decoder_activation (str, opcional, padrão "relu") — Função de ativação aplicada após a camada de projeção do decodificador de profundidade.
  • semantic_loss_ignore_index (int, opcional, padrão 255) — Índice de rótulo a ser ignorado na perda de entropia cruzada para segmentação semântica.

Esta é a classe de configuração para armazenar a configuração de um modelo Tipsv2 DptModel. Ela é usada para instanciar um modelo Tipsv2 Dpt de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os valores padrão resultará em uma configuração semelhante à do google/tipsv2-b14-dpt

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import Tipsv2DptConfig, Tipsv2DptForDensePrediction

>>> configuration = Tipsv2DptConfig()
>>> model = Tipsv2DptForDensePrediction(configuration)
>>> configuration = model.config

Dicasv2DptImageProcessor

classe transformers.Tipsv2DptImageProcessor

< >

( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 448, 'width': 448}): 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 a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 2) — Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional, padrão False) — Indica se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • Returns tensores empilhados se definido como 'pt', caso contrário, retorna uma lista de tensores. —

Constrói um processador de imagem Tipsv2DptImageProcessor.

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.

pré-processamento

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature

Parâmetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • image_like_kwargs (dict[str, Any], opcional) — Flag para desenvolvedores destinada a entradas adicionais semelhantes a imagens que também serão pré-processadas. Use apenas se passar as 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 a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.

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

< >

( outputstarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None ) → list[dict[str, torch.Tensor]]

Parâmetros

  • outputs (DepthEstimatorOutput ou Tipsv2DptDensePredictorOutput) — Saídas brutas do modelo.
  • target_sizes (TensorType ou list[tuple[int, int]], opcional) — Tensor de forma (batch_size, 2) ou lista de tuplas (tuple[int, int]) contendo o tamanho alvo (altura, largura) de cada imagem no lote. Se deixado como None, as previsões não serão redimensionadas.

Retorna

list[dict[str, torch.Tensor]]

Uma lista de dicionários de tensores representando as previsões de profundidade processadas.

Converte a saída de Tipsv2DptForDepthEstimation ou Tipsv2DptForDensePrediction em previsões finais de profundidade.

post_process_normal_estimation

< >

( outputstarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None )

Parâmetros

  • outputs (Tipsv2DptNormalEstimatorOutput ou Tipsv2DptDensePredictorOutput) — Saídas brutas do modelo.
  • target_sizes (TensorType ou list[tuple[int, int]], opcional) — Tensor de forma (batch_size, 2) ou lista de tuplas (tuple[int, int]) contendo o tamanho alvo (altura, largura) de cada imagem no lote. Se deixado como None, as previsões não serão redimensionadas.

Converte a saída de Tipsv2DptForNormalEstimation ou Tipsv2DptForDensePrediction em mapas de normais de superfície normalizados em L2.

post_process_semantic_segmentation

< >

( outputstarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]

Parâmetros

  • outputs (SemanticSegmenterOutput ou Tipsv2DptDensePredictorOutput) — Saídas brutas do modelo.
  • target_sizes [(TensorType or list[tuple[int, int]], optional) — Tensor de forma (batch_size, 2) ou lista de tuplas (tuple[int, int]) contendo o tamanho alvo (altura, largura) de cada imagem no lote. Se deixado como None, as previsões não serão redimensionadas.
  • return_segmentation_scores (bool, opcional, padrão False) — Indica se as pontuações de segmentação devem ser retornadas 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 Tipsv2DptForSemanticSegmentation ou Tipsv2DptForDensePrediction em mapas de segmentação semântica.

Dicas

classe transformers.Tipsv2DptForDensePrediction

< >

( config: Tipsv2DptConfig )

Parâmetros

  • config (Tipsv2DptConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo TIPSv2-DPT com três cabeças independentes para estimativa de profundidade, estimativa de normais de superfície e segmentação semântica — executando uma única passagem de frente de um backbone compartilhado.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: Tensor**kwargs: Unpack ) → Tipsv2DptDensePredictorOutput or tuple(torch.Tensor)

Parâmetros

Retorna

Tipsv2DptDensePredictorOutput ou tuple(torch.Tensor)

Um Tipsv2DptDensePredictorOutput 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 (Tipsv2DptConfig) e das entradas.

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

  • predicted_depth (torch.Tensor de forma (batch_size, height, width), opcional) — Profundidade prevista para cada pixel.

  • normals (torch.Tensor de forma (batch_size, 3, height, width)) — Previsões brutas do mapa de normais (não normalizadas).

  • segmentation_logits (torch.Tensor de forma (batch_size, config.num_labels, height, width)) — Pontuações de classificação para cada pixel.

    Os logits retornados não necessariamente têm o mesmo tamanho que os `pixel_values` passados como entradas. Isso é para evitar fazer duas interpolações e perder alguma qualidade quando um usuário precisa redimensionar os logits para o tamanho da imagem original como pós-processamento. Você deve sempre verificar a forma dos seus logits e redimensionar conforme necessário.

  • 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 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 (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

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

Exemplo:

>>> import torch
>>> from transformers import Tipsv2DptForDensePrediction, AutoImageProcessor
>>> from transformers.image_utils import load_image

>>> model_id = "google/tipsv2-b14-dpt"
>>> model = Tipsv2DptForDensePrediction.from_pretrained(model_id, device_map="auto")
>>> image_processor = AutoImageProcessor.from_pretrained(model_id)

>>> image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")
>>> inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

>>> # outputs.predicted_depth: (batch_size, height, width) tensor with predicted depth in meters
>>> # outputs.normals: (batch_size, 3, height, width) tensor with normals in XYZ format (unnormalized)
>>> # outputs.segmentation_logits: (batch_size, config.num_labels, height, width) tensor with segmentation logits
>>> depth_results = image_processor.post_process_depth_estimation(outputs, target_sizes=[(image.height, image.width)])
>>> normal_results = image_processor.post_process_normal_estimation(outputs, target_sizes=[(image.height, image.width)])
>>> segmentation_results = image_processor.post_process_semantic_segmentation(outputs, target_sizes=[(image.height, image.width)])

>>> predicted_depth = depth_results[0]["predicted_depth"]  # (height, width) tensor with predicted depth in meters
>>> normals = normal_results[0]["normals"]  # (3, height, width) tensor with normals in XYZ format (L2-normalized)
>>> segmentation = segmentation_results[0]  # (height, width) tensor with class ids

Dicasv2DptForDepthEstimation

classe transformers.Tipsv2DptForDepthEstimation

< >

( config: Tipsv2DptConfig )

Parâmetros

  • config (Tipsv2DptConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo TIPSv2-DPT com uma cabeça de estimativa de profundidade monocular.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: Unpack ) → DepthEstimatorOutput or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Tipsv2DptImageProcessor. Consulte Tipsv2DptImageProcessor.call() para mais detalhes (processor_class usa Tipsv2DptImageProcessor para processar as imagens).
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de estimativa de profundidade reais para o cálculo da perda.

Retorna

DepthEstimatorOutput ou tuple(torch.Tensor)

Um DepthEstimatorOutput 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 (Tipsv2DptConfig) e das entradas.

O método forward de Tipsv2DptForDepthEstimation 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 regressão se config.num_labels==1).

  • predicted_depth (torch.Tensor de forma (batch_size, height, width)) — Profundidade prevista para cada pixel.

  • 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, num_channels, height, width).

    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 (um para cada camada) com forma (batch_size, num_heads, patch_size, sequence_length).

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

Exemplo:

>>> import torch
>>> from transformers import AutoModelForDepthEstimation, AutoImageProcessor
>>> from transformers.image_utils import load_image

>>> model_id = "google/tipsv2-b14-dpt"
>>> model = AutoModelForDepthEstimation.from_pretrained(model_id, device_map="auto")
>>> image_processor = AutoImageProcessor.from_pretrained(model_id)

>>> image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")
>>> inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

>>> results = image_processor.post_process_depth_estimation(outputs, target_sizes=[(image.height, image.width)])
>>> predicted_depth = results[0]["predicted_depth"]  # (height, width) tensor with predicted depth in meters

Dicasv2DptForNormalEstimation

classe transformers.Tipsv2DptForNormalEstimation

< >

( config: Tipsv2DptConfig )

Parâmetros

  • config (Tipsv2DptConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo TIPSv2-DPT com uma cabeça de estimativa de normais de superfície.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.Tensor] = None**kwargs: Unpack ) → Tipsv2DptNormalEstimatorOutput or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Tipsv2DptImageProcessor. Consulte Tipsv2DptImageProcessor.call() para mais detalhes (processor_class usa Tipsv2DptImageProcessor para processar as imagens).
  • labels (torch.Tensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].

Retorna

Tipsv2DptNormalEstimatorOutput ou tuple(torch.Tensor)

Um Tipsv2DptNormalEstimatorOutput 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 (Tipsv2DptConfig) e das entradas.

O método forward de Tipsv2DptForNormalEstimation 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 estimativa normal.
  • normals (torch.Tensor de forma (batch_size, num_labels, height, width)) — Previsões brutas do mapa de normais produzidas pelo modelo (não normalizadas).
  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings + um para a saída de cada estágio) de forma (batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas dos embeddings iniciais.
  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um por camada) com a forma (batch_size, num_heads, sequence_length, sequence_length). Pesos das atenções após o softmax de atenção.

Exemplo:

>>> import torch
>>> from transformers import Tipsv2DptForNormalEstimation, AutoImageProcessor
>>> from transformers.image_utils import load_image

>>> model_id = "google/tipsv2-b14-dpt"
>>> model = Tipsv2DptForNormalEstimation.from_pretrained(model_id, device_map="auto")
>>> image_processor = AutoImageProcessor.from_pretrained(model_id)

>>> image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")
>>> inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

>>> results = image_processor.post_process_normal_estimation(outputs, target_sizes=[(image.height, image.width)])
>>> normals = results[0]["normals"]  # (3, height, width) tensor with normals in XYZ format (L2-normalized)

Dicasv2DptForSemanticSegmentation

classe transformers.Tipsv2DptForSemanticSegmentation

< >

( config: Tipsv2DptConfig )

Parâmetros

  • config (Tipsv2DptConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo TIPSv2-DPT com uma cabeça de segmentação semântica.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: Tensorlabels: typing.Optional[torch.LongTensor] = None**kwargs: Unpack ) → SemanticSegmenterOutput or tuple(torch.Tensor)

Parâmetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando Tipsv2DptImageProcessor. Consulte Tipsv2DptImageProcessor.call() para mais detalhes (processor_class usa Tipsv2DptImageProcessor para processar as imagens).
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de segmentação semântica de verdade para o cálculo da perda. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels > 1, uma perda de classificação é calculada (Cross-Entropy).

Retorna

SemanticSegmenterOutput ou tuple(torch.Tensor)

Um SemanticSegmenterOutput 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 (Tipsv2DptConfig) e das entradas.

O método forward de Tipsv2DptForSemanticSegmentation 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 regressão se config.num_labels==1).

  • logits (torch.Tensor de forma (batch_size, config.num_labels, logits_height, logits_width)) — Pontuações de classificação para cada pixel.

    Os logits retornados não necessariamente têm o mesmo tamanho que os pixel_values passados como entradas. Isso é para evitar fazer duas interpolações e perder alguma qualidade quando um usuário precisa redimensionar os logits para o tamanho da imagem original como pós-processamento. Você deve sempre verificar a forma dos seus logits e redimensioná-los conforme necessário.

  • 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, patch_size, 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 (um para cada camada) com forma (batch_size, num_heads, patch_size, sequence_length).

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

Exemplo:

>>> import torch
>>> from transformers import AutoModelForSemanticSegmentation, AutoImageProcessor
>>> from transformers.image_utils import load_image

>>> model_id = "google/tipsv2-b14-dpt"
>>> model = AutoModelForSemanticSegmentation.from_pretrained(model_id, device_map="auto")
>>> image_processor = AutoImageProcessor.from_pretrained(model_id)

>>> image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/room.jpg")
>>> inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

>>> results = image_processor.post_process_semantic_segmentation(outputs, target_sizes=[(image.height, image.width)])
>>> segmentation_map = results[0]  # (height, width) tensor with class ids
Update on GitHub

←TIPSv2 TrOCR→