Transformers documentation
Processador de imagem
Processador de imagem
Um image processor é responsável por carregar imagens (opcionalmente), preparar os recursos de entrada para modelos de visão e realizar o pós-processamento de suas saídas. Isso inclui transformações como redimensionamento, normalização e conversão para tensores do PyTorch e do Numpy. Também pode incluir o pós-processamento específico do modelo, como a conversão de logits em máscaras de segmentação.
Os processadores de imagem utilizam uma arquitetura baseada em backends. A hierarquia de classes é:
- BaseImageProcessor — classe base abstrata (apenas para compatibilidade reversa; não instancie diretamente)
- TorchvisionBackend — o backend padrão baseado em torchvision. Acelerado por GPU e significativamente mais rápido que o backend PIL. Todos os modelos expõem uma classe
<Model>ImageProcessorque herda dele. - PilBackend — o backend alternativo baseado em PIL/NumPy. Portável e exclusivo para CPU. Disponível apenas para modelos mais antigos por meio de uma classe
<Model>ImageProcessorPil; útil quando é necessária paridade numérica exata com a implementação original.
- TorchvisionBackend — o backend padrão baseado em torchvision. Acelerado por GPU e significativamente mais rápido que o backend PIL. Todos os modelos expõem uma classe
Ambos os backends expõem a mesma API. Use o atributo backend para inspecionar qual backend um processador carregado utiliza (por exemplo, processor.backend == "torchvision").
Passe backend para AutoImageProcessor.from_pretrained() para selecionar um backend. Quando backend é omitido (o padrão), o torchvision é escolhido se estiver instalado; caso contrário, o PIL é utilizado. Alguns modelos que usam interpolação Lanczos (Chameleon, Flava, Idefics3, SmolVLM) são uma exceção e usam PIL como padrão quando o torchvision < 0.27. Forçar backend="torchvision" para esses modelos com torchvision < 0.27 recorre à interpolação BICUBIC, pois o torchvision suporta Lanczos para tensors apenas a partir da versão 0.27.
from transformers import AutoImageProcessor
# Default: picks torchvision if available, otherwise pil
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
# Explicitly request torchvision
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50", backend="torchvision")
# Explicitly request PIL
processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50", backend="pil")Ao usar o backend torchvision, você pode definir o argumento device para especificar o dispositivo em que o processamento deve ser realizado. Por padrão, o processamento é feito no mesmo dispositivo dos inputs, caso os inputs sejam tensors, ou na CPU, caso contrário.
import torch
from torchvision.io import read_image
from transformers import DetrImageProcessor
device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
images = read_image("image.jpg")
processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
images_processed = processor(images, return_tensors="pt", device=device)Aqui estão algumas comparações de velocidade entre os backends torchvision e PIL para os modelos DETR e RT-DETR, e como eles impactam o tempo total de inferência:
Esses benchmarks foram executados em uma instância AWS EC2 g5.2xlarge, utilizando uma GPU NVIDIA A10G Tensor Core.
ImageProcessingMixin
Este é um mixin de processador de imagem usado para fornecer funcionalidade de salvamento/carregamento para extratores de recursos sequenciais e de imagem.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )
Parâmetros
- pretrained_model_name_or_path (
strouos.PathLike) — Pode ser:- uma string, o model id de um image_processor pré-treinado hospedado em um repositório de modelos no huggingface.co.
- um caminho para um diretório contendo um arquivo de processador de imagem salvo usando o método
save_pretrained(), por exemplo,
./my_model_directory/. - um caminho para um arquivo JSON de processador de imagem salvo arquivo, por exemplo,
./my_model_directory/preprocessor_config.json.
- cache_dir (
strouos.PathLike, opcional) — Caminho para um diretório em que o processador de imagem de um modelo pré-treinado baixado deve ser armazenado em cache, caso o cache padrão não deva ser usado. - force_download (
bool, opcional, padrãoFalse) — Indica se deve forçar o (re)download dos arquivos do processador de imagem e substituir as versões em cache, caso existam. - proxies (
dict[str, str], opcional) — Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo,{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}.Os proxies são usados em cada solicitação. - token (
stroubool, opcional) — O token a ser usado como autorização bearer HTTP para arquivos remotos. SeTrue, ou não especificado, usará o token gerado ao executarhf auth login(armazenado em~/.huggingface). - revision (
str, opcional, padrão"main") — A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag ou um id de commit, pois utilizamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, de modo querevisionpode ser qualquer identificador permitido pelo git.
Instancie um tipo de ImageProcessingMixin a partir de um processador de imagem.
Exemplos:
# We can't instantiate directly the base class *ImageProcessingMixin* so let's show the examples on a
# derived class: *CLIPImageProcessor*
image_processor = CLIPImageProcessor.from_pretrained(
"openai/clip-vit-base-patch32"
) # Download image_processing_config from huggingface.co and cache.
image_processor = CLIPImageProcessor.from_pretrained(
"./test/saved_model/"
) # E.g. image processor (or model) was saved using *save_pretrained('./test/saved_model/')*
image_processor = CLIPImageProcessor.from_pretrained("./test/saved_model/preprocessor_config.json")
image_processor = CLIPImageProcessor.from_pretrained(
"openai/clip-vit-base-patch32", do_normalize=False, foo=False
)
assert image_processor.do_normalize is False
image_processor, unused_kwargs = CLIPImageProcessor.from_pretrained(
"openai/clip-vit-base-patch32", do_normalize=False, foo=False, return_unused_kwargs=True
)
assert image_processor.do_normalize is False
assert unused_kwargs == {"foo": False}save_pretrained
< source >( save_directory: str | os.PathLikepush_to_hub: bool = False**kwargs )
Parâmetros
- save_directory (
strouos.PathLike) — Diretório onde o arquivo JSON do processador de imagem será salvo (será criado se não existir). - push_to_hub (
bool, opcional, padrãoFalse) — Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino comrepo_id(por padrão, será usado o nome desave_directoryno seu namespace). - kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados ao método push_to_hub().
Salve um objeto de processador de imagens no diretório save_directory para que ele possa ser recarregado usando o método de classe from_pretrained().
BatchFeature
classe transformers.BatchFeature
< source >( data: dict[str, typing.Any] | None = Nonetensor_type: None | str | transformers.utils.generic.TensorType = Noneskip_tensor_conversion: list[str] | set[str] | None = None )
Parâmetros
- data (
dict, opcional) — Dicionário de listas/arrays/tensors retornados pelos métodos call/pad (‘input_values’, ‘attention_mask’, 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. - skip_tensor_conversion (
list[str]ouset[str], opcional) — Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quandotensor_typefor especificado.
Contém a saída dos métodos pad() e __call__ específicos do extrator de recursos.
Esta classe é derivada de um dicionário python e pode ser usada como um dicionário.
convert_to_tensors
< source >( tensor_type: str | transformers.utils.generic.TensorType | None = Noneskip_tensor_conversion: list[str] | set[str] | None = None )
Parâmetros
- tensor_type (
strou TensorType, opcional) — O tipo de tensores a ser usado. Se forstr, deve ser um dos valores da enumeração TensorType. SeNone, nenhuma modificação é feita. - skip_tensor_conversion (
list[str]ouset[str], opcional) — Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quandotensor_typefor especificado.
Converta o conteúdo interno em tensores.
Nota: Valores que não possuem uma estrutura semelhante a um array (por exemplo, strings, dicts, listas de strings) são automaticamente ignorados e não serão convertidos em tensors. Arrays irregulares (listas de arrays com comprimentos diferentes) ainda são tentados, embora possam gerar erros durante a conversão.
para
< source >( *args**kwargs ) → BatchFeature
Parâmetros
- args (
Tuple) — Será passado para a funçãoto(...)dos tensors. - kwargs (
Dict, opcional) — Será passado para a funçãoto(...)dos tensores. Para habilitar a transferência de dados assíncrona, defina a flagnon_blockingemkwargs(padrão:False).
Retorna
A mesma instância após a modificação.
Envie todos os valores para o dispositivo chamando v.to(*args, **kwargs) (somente PyTorch). Isso deve suportar o casting em diferentes dtypes e enviar o BatchFeature para um device diferente.
BaseImageProcessor
classe transformers.BaseImageProcessor
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Classe base para processadores de imagem com uma arquitetura de backend baseada em herança.
Esta classe define o pipeline de pré-processamento: validação de kwargs, preparação da entrada e despacho para o método _preprocess do backend. As subclasses de backend (TorchvisionBackend, PilBackend) herdam desta classe e implementam as operações de imagem reais (redimensionar, recortar, reescalar, normalizar, etc.). Os processadores de imagem específicos de um modelo, por sua vez, herdam da classe de backend apropriada.
Visão geral da arquitetura
A hierarquia de classes é:
BaseImageProcessor (esta classe) ├── TorchvisionBackend (acelerado por GPU, torch.Tensor) │ └── ModelImageProcessor (ex.: LlavaNextImageProcessor) └── PilBackend (CPU portátil, np.ndarray) └── ModelImageProcessorPil (ex.: CLIPImageProcessorPil)
O fluxo de pré-processamento é:
call() → preprocess() → _preprocess_image_like_inputs() → _prepare_image_like_inputs() (chama process_image para cada imagem) → _preprocess() (operações em lote: redimensionar, recortar, etc.)
process_image: Implementado pelos backends. Converte uma única entrada bruta (PIL, NumPy ou Tensor) para o formato de trabalho do backend (torch.Tensor ou np.ndarray), gerencia a conversão para RGB e a reordenação dos canais._preprocess: Implementado pelos backends. Executa o processamento real do lote (redimensionar, recorte central, reescalar, normalizar, preencher) e retorna umBatchFeature.
Implementação básica
Para processadores que precisam apenas de operações padrão (redimensionar, recortar no centro, reescalar, normalizar), herde de um backend e defina atributos de classe:
from transformers.image_processing_backends import PilBackend
class MyImageProcessorPil(PilBackend): resample = PILImageResampling.BILINEAR image_mean = IMAGENET_DEFAULT_MEAN image_std = IMAGENET_DEFAULT_STD size = {“height”: 224, “width”: 224} do_resize = True do_rescale = True do_normalize = True
O método _preprocess do backend trata o pipeline padrão automaticamente.
Processamento Personalizado
Para processadores que exigem lógica personalizada (por exemplo, processamento baseado em patches, múltiplos tipos de entrada), sobrescreva _preprocess no processador específico do seu modelo. O método _preprocess recebe imagens já preparadas (convertidas para o formato do backend com a ordem de canais primeiro) e executa o processamento real:
class MyImageProcessor(TorchvisionBackend): def _preprocess(self, images, do_resize, size, do_normalize, image_mean, image_std, **kwargs):
Agrupar imagens por forma para operações em lote eficientes
grouped_images, grouped_images_index = group_images_by_shape(images) processed_groups = {} for shape, stacked_images in grouped_images.items(): if do_resize: stacked_images = self.resize(stacked_images, size=size) if do_normalize: stacked_images = self.normalize(stacked_images, mean=image_mean, std=image_std) processed_groups[shape] = stacked_images processed_images = reorder_images(processed_groups, grouped_images_index) return BatchFeature(data={“pixel_values”: processed_images})
Para processadores que lidam com múltiplos tipos de entrada (por exemplo, imagens + mapas de segmentação), sobrescreva _preprocess_image_like_inputs:
def _preprocess_image_like_inputs( self, images: ImageInput, segmentation_maps: ImageInput | None = None, kwargs, ) -> BatchFeature: images = self._prepare_image_like_inputs(images,kwargs) batch_feature = self._preprocess(images, **kwargs)
if segmentation_maps is not None: maps = self._prepare_image_like_inputs(segmentation_maps, kwargs) batch_feature[“labels”] = self._preprocess(maps,kwargs).pixel_values
return batch_feature
Estendendo o Comportamento do Backend
Para personalizar operações para um backend específico, crie uma subclasse do backend e sobrescreva seus métodos:
from transformers.image_processing_backends import TorchvisionBackend, PilBackend
class MyTorchvisionProcessor(TorchvisionBackend): def resize(self, image, size, **kwargs):
Lógica de redimensionamento personalizada para torchvision
return super().resize(image, size, **kwargs)
class MyPilProcessor(PilBackend): def resize(self, image, size, **kwargs):
Lógica de redimensionamento personalizada para PIL
return super().resize(image, size, **kwargs)
Parâmetros Personalizados
Para adicionar parâmetros além de ImagesKwargs, crie uma classe de kwargs personalizada e defina-a como valid_kwargs:
class MyImageProcessorKwargs(ImagesKwargs): custom_param: int | None = None
class MyImageProcessor(TorchvisionBackend): valid_kwargs = MyImageProcessorKwargs custom_param = 10 # valor padrão
Observações principais
- A seleção do backend é feita no nível da classe: herde de
TorchvisionBackendouPilBackend - Os backends recebem imagens como
torch.Tensor(Torchvision) ounp.ndarray(PIL), sempre com os canais primeiro - Todas as imagens têm a dimensão de canal primeiro durante o processamento, independentemente do backend
- Argumentos não fornecidos pelos usuários assumem os valores dos atributos da classe
- As classes de backend encapsulam a lógica específica do backend (redimensionamento, normalização, etc.) e podem ser substituídas
center_crop
< source >( image: ndarraysize: dictdata_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs )
Parâmetros
- image (
np.ndarray) — Imagem para recorte central. - size (
dict[str, int]) — Tamanho da imagem de saída. - data_format (
strouChannelDimension, opcional) — O formato da dimensão de canal para a imagem de saída. Se não for definido, o formato da dimensão de canal da imagem de entrada será usado. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- input_data_format (
ChannelDimensionoustr, 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"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
Centraliza o recorte de uma imagem para (size["height"], size["width"]). Se o tamanho de entrada for menor que crop_size em qualquer borda, a imagem é preenchida com 0 e, em seguida, recortada no centro.
normalize
< source >( image: ndarraymean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]data_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs ) → np.ndarray
Parâmetros
- image (
np.ndarray) — Imagem a ser normalizada. - mean (
floatouIterable[float]) — Média da imagem a ser usada para normalização. - std (
floatouIterable[float]) — Desvio padrão da imagem a ser usado para normalização. - data_format (
strouChannelDimension, opcional) — O formato da dimensão de canal para a imagem de saída. Se não for definido, o formato da dimensão de canal da imagem de entrada será usado. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- input_data_format (
ChannelDimensionoustr, 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"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
Retorna
np.ndarray
A imagem normalizada.
Normalizar uma imagem. image = (image - image_mean) / image_std.
pré-processamento
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*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, definado_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 decenter_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çãoPILImageResampling. Tem efeito apenas sedo_resizeestiver definido comoTrue. - do_rescale (
bool, kwargs, opcional) — Se deve reescalar a imagem. - rescale_factor (
float, kwargs, opcional) — Fator de redimensionamento para redimensionar a imagem, casodo_rescaleesteja definido comoTrue. - 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 sedo_normalizeestiver definido comoTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, opcional) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas sedo_normalizeestiver definido comoTrue. - 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. Sepad_sizenão for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quandodo_pad=True. - do_center_crop (
bool, kwargs, opcional) — Se deve recortar a imagem centralmente. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — ApenasChannelDimension.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"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais)."none"ouChannelDimension.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.
Processa uma única imagem bruta para o formato de trabalho do backend.
Implementado por subclasses de backend (TorchvisionBackend, PilBackend). Converte uma entrada bruta (imagem PIL, array NumPy ou Tensor torch) para o formato interno do backend (torch.Tensor para Torchvision, np.ndarray para PIL), trata a conversão para RGB e garante a ordem de canais primeiro.
rescale
< source >( image: ndarrayscale: floatdata_format: str | transformers.image_utils.ChannelDimension | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs ) → np.ndarray
Parâmetros
- image (
np.ndarray) — Imagem a ser redimensionada. - scale (
float) — Fator de escala para reescalar os valores de pixels. - data_format (
strouChannelDimension, opcional) — O formato da dimensão de canal para a imagem de saída. Se não for definido, o formato da dimensão de canal da imagem de entrada será usado. Pode ser um dos seguintes:"channels_first"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
- input_data_format (
ChannelDimensionoustr, 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"ouChannelDimension.FIRST: imagem no formato (num_channels, height, width)."channels_last"ouChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
Retorna
np.ndarray
A imagem redimensionada.
Redimensiona uma imagem por um fator de escala. image = image * scale.
TorchvisionBackend
classe transformers.TorchvisionBackend
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Backend Torchvision para processamento de imagens em lote com aceleração por GPU.
Centralizar o recorte de uma imagem usando Torchvision.
convert_to_rgb
< source >( image: torch.Tensorinput_data_format: str | transformers.image_utils.ChannelDimension | None = None )
Converte uma imagem para o formato RGB.
Converte uma única URL ou um conjunto de URLs / caminhos em objetos torch.Tensor.
Objetos de imagem já válidos (tensors, arrays numpy, Imagens PIL) são passados sem alterações, de modo que os chamadores que pré-carregam imagens não sejam afetados.
normalize
< source >( image: torch.Tensormean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]inplace: bool = False**kwargs )
Normalizar uma imagem usando Torchvision.
pad
< source >( images: listpad_size: SizeDict = Nonefill_value: int | None = 0padding_mode: str | None = 'constant'return_mask: bool = Falsedisable_grouping: bool | None = Falseis_nested: bool | None = False**kwargs )
Preencha as imagens usando Torchvision com operações em lote.
process_image
< source >( image: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]do_convert_rgb: bool | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = Nonedevice: typing.Optional[ForwardRef('torch.device')] = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Processa uma única imagem para o backend torchvision.
Redimensione uma imagem por um fator de escala usando Torchvision.
rescale_and_normalize
< source >( images: torch.Tensordo_rescale: boolrescale_factor: floatdo_normalize: boolimage_mean: float | list[float]image_std: float | list[float] )
Redimensione e normalize imagens usando Torchvision (fuso para eficiência).
resize
< source >( image: torch.Tensorsize: SizeDictresample: PILImageResampling | tvF.InterpolationMode | int | None = Noneantialias: bool = True**kwargs )
Redimensione uma imagem usando Torchvision.
PilBackend
classe transformers.PilBackend
< source >( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Backend PIL/NumPy para processamento de imagens portátil apenas em CPU.
Centralizar o recorte de uma imagem usando NumPy.
convert_to_rgb
< source >( image: ndarrayinput_data_format: str | transformers.image_utils.ChannelDimension | None = None )
Converte uma imagem para o formato RGB.
normalize
< source >( image: ndarraymean: float | collections.abc.Iterable[float]std: float | collections.abc.Iterable[float]**kwargs )
Normalizar uma imagem usando NumPy.
pad
< source >( images: listpad_size: SizeDict = Nonefill_value: int | None = 0padding_mode: str | None = 'constant'return_mask: bool = False**kwargs )
Preencha as imagens até o tamanho especificado usando NumPy.
process_image
< source >( image: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]do_convert_rgb: bool | None = Noneinput_data_format: str | transformers.image_utils.ChannelDimension | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )
Processa uma única imagem para o backend PIL.
Redimensione uma imagem por um fator de escala usando NumPy.
resize
< source >( image: ndarraysize: SizeDictresample: PILImageResampling | None = Nonereducing_gap: int | None = None**kwargs )
Redimensione uma imagem usando PIL/NumPy.