diffusers/v0.43.0/pt/api/image_processor.md

Processador de Imagem VAE

O VaeImageProcessor fornece uma API unificada para StableDiffusionPipelines prepararem as entradas de imagem para a codificação por VAE e processarem os resultados após a decodificação. Isso inclui transformações como redimensionamento, normalização e conversão entre PIL Image, PyTorch e arrays NumPy.

Todos os pipelines com VaeImageProcessor aceitam PIL Image, tensor do PyTorch ou arrays NumPy como entradas de imagem e retornam saídas com base no argumento output_type definido pelo usuário. Você pode passar latentes de imagem codificados diretamente para o pipeline e retornar latentes do pipeline como uma saída específica com o argumento output_type (por exemplo, output_type="latent"). Isso permite pegar os latentes gerados de um pipeline e passá-los para outro pipeline como entrada, sem sair do espaço latente. Também facilita muito o uso de vários pipelines juntos, passando tensores do PyTorch diretamente entre diferentes pipelines.

VaeImageProcessor[[diffusers.VaeImageProcessor]]

diffusers.VaeImageProcessor[[diffusers.VaeImageProcessor]]

diffusers.VaeImageProcessor(do_resize: bool = True, vae_scale_factor: int = 8, vae_latent_channels: int = 4, resample: str = 'lanczos', reducing_gap: int | None = None, do_normalize: bool = True, do_binarize: bool = False, do_convert_rgb: bool = False, do_convert_grayscale: bool = False)

Fonte

Parâmetros:

do_resize (bool, opcional, padrão True) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de vae_scale_factor. Pode aceitar os argumentos height e width do método image_processor.VaeImageProcessor.preprocess().

vae_scale_factor (int, opcional, padrão 8) : Fator de escala do VAE. Se do_resize for True, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (str, opcional, padrão lanczos) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (bool, opcional, padrão True) : Se normalizar a imagem para [-1,1].

do_binarize (bool, opcional, padrão False) : Se deve binarizar a imagem para 0/1.

do_convert_rgb (bool, opcional, padrão é False) : Se as imagens devem ser convertidas para o formato RGB.

do_convert_grayscale (bool, opcional, padrão é False) : Se as imagens devem ser convertidas para o formato de escala de cinza.

Processador de imagem para VAE.

apply_overlay[[diffusers.VaeImageProcessor.apply_overlay]]

apply_overlay(mask: Image, init_image: Image, image: Image, crop_coords: tuple[int, int, int, int] | None = None)

Fonte

Parâmetros:

mask (PIL.Image.Image) : A imagem de máscara que destaca as regiões a serem sobrepostas.

init_image (PIL.Image.Image) : A imagem original à qual a sobreposição é aplicada.

image (PIL.Image.Image) : A imagem a ser sobreposta à original.

crop_coords (tuple[int, int, int, int], opcional) : Coordenadas para recortar a imagem. Se fornecidas, a imagem será recortada de acordo.

Retorna: PIL.Image.Image

A imagem final com a sobreposição aplicada.

Aplica uma sobreposição da máscara e da imagem reparada sobre a imagem original.

binarizar[[diffusers.VaeImageProcessor.binarize]]

binarize(image: Image)

Fonte

Parâmetros:

image (PIL.Image.Image) : A entrada da imagem, deve ser uma imagem PIL.

Retorna: PIL.Image.Image

A imagem binarizada. Valores menores que 0,5 são definidos como 0, valores maiores que 0,5 são definidos como 1.

Crie uma máscara.

blur[[diffusers.VaeImageProcessor.blur]]

blur(image: Image, blur_factor: int = 4)

Fonte

Parâmetros:

image (PIL.Image.Image) : A imagem PIL a ser convertida para escala de cinza.

Retorna: PIL.Image.Image

A imagem PIL convertida para escala de cinza.

Aplica um desfoque gaussiano a uma imagem.

convert_to_grayscale[[diffusers.VaeImageProcessor.convert_to_grayscale]]

convert_to_grayscale(image: Image)

Fonte

Parâmetros:

image (PIL.Image.Image) : A imagem de entrada a ser convertida.

Retorna: PIL.Image.Image

A imagem convertida para escala de cinza.

Converte uma imagem PIL fornecida para escala de cinza.

convert_to_rgb[[diffusers.VaeImageProcessor.convert_to_rgb]]

convert_to_rgb(image: Image)

Fonte

Parâmetros:

image (PIL.Image.Image) : A imagem PIL a ser convertida para RGB.

Retorna: PIL.Image.Image

A imagem PIL convertida para RGB.

Converte uma imagem PIL para o formato RGB.

denormalizar[[diffusers.VaeImageProcessor.denormalize]]

denormalize(images: typing.Union[numpy.ndarray, torch.Tensor])

Fonte

Parâmetros:

images (np.ndarray ou torch.Tensor) : O array de imagem para desnornalizar.

Retorna: np.ndarray ou torch.Tensor

O array de imagem denormalizado.

Desnormalize um array de imagem para [0,1].

get_crop_region[[diffusers.VaeImageProcessor.get_crop_region]]

get_crop_region(mask_image: Image, width: int, height: int, pad = 0)

Fonte

Parâmetros:

mask_image (PIL.Image.Image) : Imagem de máscara.

width (int) : Largura da imagem a ser processada.

height (int) : Altura da imagem a ser processada.

pad (int, opcional) : Preenchimento a ser adicionado à região de recorte. Padrão é 0.

Retorna: tuple

(x1, y1, x2, y2) representam uma região retangular que contém todas as áreas mascaradas em uma imagem e corresponde à proporção original.

Encontra uma região retangular que contém todas as áreas mascaradas em uma imagem e expande a região para corresponder à proporção de aspecto da imagem original; por exemplo, se o usuário desenhou a máscara em uma região de 128x32 e as dimensões para processamento são 512x512, a região será expandida para 128x128.

get_default_height_width[[diffusers.VaeImageProcessor.get_default_height_width]]

get_default_height_width(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int | None = None, width: int | None = None)

Fonte

Parâmetros:

image (PIL.Image.Image | np.ndarray | torch.Tensor) : A entrada de imagem, que pode ser uma imagem PIL, um array NumPy ou um tensor PyTorch. Se for um array NumPy, ele deve ter a forma [batch, height, width] ou [batch, height, width, channels]. Se for um tensor PyTorch, ele deve ter a forma [batch, channels, height, width].

height (int | None, opcional, padrão None) : A altura da imagem pré-processada. Se None, a altura da entrada image será utilizada.

width (int | None, opcional, padrão None) : A largura da imagem pré-processada. Se None, a largura da entrada image será utilizada.

Retorna: tuple[int, int]

Uma tupla contendo a altura e a largura, ambas redimensionadas para o múltiplo inteiro mais próximo de vae_scale_factor.

Retorna a altura e a largura da imagem, reduzidas para o próximo múltiplo inteiro de vae_scale_factor.

normalizar[[diffusers.VaeImageProcessor.normalize]]

normalize(images: typing.Union[numpy.ndarray, torch.Tensor])

Fonte

Parâmetros:

images (np.ndarray ou torch.Tensor) : O array de imagem a ser normalizado.

Retorna: np.ndarray ou torch.Tensor

O array de imagem normalizado.

Normalizar um array de imagem para [-1,1].

numpy_to_pil[[diffusers.VaeImageProcessor.numpy_to_pil]]

numpy_to_pil(images: ndarray)

Fonte

Parâmetros:

images (np.ndarray) : O array de imagem a ser convertido para o formato PIL.

Retorna: list[PIL.Image.Image]

Uma lista de imagens PIL.

Converte uma imagem numpy ou um lote de imagens para uma imagem PIL.

numpy_to_pt[[diffusers.VaeImageProcessor.numpy_to_pt]]

numpy_to_pt(images: ndarray)

Fonte

Parâmetros:

images (np.ndarray) : O array de imagem do NumPy a ser convertido para o formato PyTorch.

Retorna: torch.Tensor

Uma representação de tensor do PyTorch das imagens.

Converte uma imagem do NumPy para um tensor do PyTorch.

pil_to_numpy[[diffusers.VaeImageProcessor.pil_to_numpy]]

pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)

Fonte

Parâmetros:

images (PIL.Image.Image ou list[PIL.Image.Image]) : A imagem PIL ou lista de imagens a serem convertidas para o formato NumPy.

Retorna: np.ndarray

Uma representação de array NumPy das imagens.

Converte uma imagem PIL ou uma lista de imagens PIL para arrays NumPy.

postprocess[[diffusers.VaeImageProcessor.postprocess]]

postprocess(image: Tensor, output_type: str = 'pil', do_denormalize: list[bool] | None = None)

Fonte

Parâmetros:

image (torch.Tensor) : A entrada de imagem, deve ser um tensor do PyTorch com a forma B x C x H x W.

output_type (str, opcional, padrão pil) : O tipo de saída da imagem, pode ser um de pil, np, pt, latent.

do_denormalize (list[bool], opcional, padrão None) : Se deve desnormalizar a imagem para [0,1]. Se None, usará o valor de do_normalize na configuração do VaeImageProcessor.

Retorna: PIL.Image.Image, np.ndarray ou torch.Tensor

A imagem pós-processada.

Pós-processe a imagem de saída do tensor para output_type.

preprocess[[diffusers.VaeImageProcessor.preprocess]]

preprocess(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], height: int | None = None, width: int | None = None, resize_mode: str = 'default', crops_coords: tuple[int, int, int, int] | None = None)

Fonte

Parâmetros:

image (PipelineImageInput) : A entrada de imagem, os formatos aceitos são imagens PIL, arrays NumPy, tensores PyTorch; Também aceita lista de formatos suportados.

height (int, opcional) : A altura da imagem pré-processada. Se None, usará o get_default_height_width() para obter a altura padrão.

width (int, opcional) : A largura pré-processada. Se None, usará get_default_height_width()` para obter a largura padrão.

resize_mode (str, opcional, padrão é default) : O modo de redimensionamento, pode ser default ou fill. Se default, a imagem será redimensionada para caber dentro da largura e altura especificadas, e pode não manter a proporção original. Se fill, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, preenchendo o espaço vazio com dados da imagem. Se crop, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, cortando o excesso. Observe que resize_mode fill e crop são suportados apenas para entrada de imagem PIL.

crops_coords (list[tuple[int, int, int, int]], opcional, padrão None) : As coordenadas de recorte para cada imagem no lote. Se None, a imagem não será recortada.

Retorna: torch.Tensor

A imagem pré-processada.

Pré-processa a entrada de imagem.

pt_to_numpy[[diffusers.VaeImageProcessor.pt_to_numpy]]

pt_to_numpy(images: Tensor)

Fonte

Parâmetros:

images (torch.Tensor) : O tensor do PyTorch a ser convertido para o formato NumPy.

Retorna: np.ndarray

Uma representação de array NumPy das imagens.

Converte um tensor do PyTorch para uma imagem do NumPy.

resize[[diffusers.VaeImageProcessor.resize]]

resize(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int, width: int, resize_mode: str = 'default')

Fonte

Parâmetros:

image (PIL.Image.Image, np.ndarray ou torch.Tensor) : A entrada da imagem, pode ser uma imagem PIL, um array numpy ou um tensor pytorch.

height (int) : A altura para redimensionar.

width (int) : A largura para redimensionar.

resize_mode (str, opcional, padrão é default) : O modo de redimensionamento a ser usado, pode ser default ou fill. Se default, a imagem será redimensionada para caber dentro da largura e altura especificadas, e pode não manter a proporção original. Se fill, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, preenchendo o espaço vazio com dados da imagem. Se crop, a imagem será redimensionada para caber dentro da largura e altura especificadas, mantendo a proporção, e então a imagem será centralizada dentro das dimensões, cortando o excesso. Observe que os resize_mode fill e crop são suportados apenas para entrada de imagem PIL.

Retorna: PIL.Image.Image, np.ndarray ou torch.Tensor

A imagem redimensionada.

Redimensionar imagem.

InpaintProcessor[[diffusers.InpaintProcessor]]

O InpaintProcessor aceita entradas mask e image e as processa juntas. Opcionalmente, pode aceitar padding_mask_crop e aplicar sobreposição de máscara.

diffusers.InpaintProcessor[[diffusers.InpaintProcessor]]

diffusers.InpaintProcessor(do_resize: bool = True, vae_scale_factor: int = 8, vae_latent_channels: int = 4, resample: str = 'lanczos', reducing_gap: int | None = None, do_normalize: bool = True, do_binarize: bool = False, do_convert_grayscale: bool = False, mask_do_normalize: bool = False, mask_do_binarize: bool = True, mask_do_convert_grayscale: bool = True)

Fonte

Processador de imagem para inpainting de imagem e máscara.

postprocess[[diffusers.InpaintProcessor.postprocess]]

postprocess(image: Tensor, output_type: str = 'pil', original_image: PIL.Image.Image | None = None, original_mask: PIL.Image.Image | None = None, crops_coords: tuple[int, int, int, int] | None = None)

Fonte

Pós-processa a imagem, aplicando opcionalmente a sobreposição da máscara

preprocess[[diffusers.InpaintProcessor.preprocess]]

preprocess(image: Image, mask: PIL.Image.Image | None = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None)

Fonte

Pré-processa a imagem e a máscara.

VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

O VaeImageProcessorLDM3D aceita entradas RGB e de profundidade e retorna saídas RGB e de profundidade.

diffusers.VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

diffusers.VaeImageProcessorLDM3D(do_resize: bool = True, vae_scale_factor: int = 8, resample: str = 'lanczos', do_normalize: bool = True)

Fonte

Parâmetros:

do_resize (bool, opcional, padrão True) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de vae_scale_factor.

vae_scale_factor (int, opcional, padrão 8) : Fator de escala do VAE. Se do_resize for True, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (str, opcional, padrão lanczos) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (bool, opcional, padrão True) : Se normalizar a imagem para [-1,1].

Processador de imagem para VAE LDM3D.

depth_pil_to_numpy[[diffusers.VaeImageProcessorLDM3D.depth_pil_to_numpy]]

depth_pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)

Fonte

Parâmetros:

images (list[PIL.Image.Image, PIL.Image.Image]) : A imagem de entrada ou lista de imagens a serem convertidas.

Retorna: np.ndarray

Um array NumPy das imagens convertidas.

Converte uma imagem PIL ou uma lista de imagens PIL para arrays NumPy.

numpy_to_depth[[diffusers.VaeImageProcessorLDM3D.numpy_to_depth]]

numpy_to_depth(images: ndarray)

Fonte

Parâmetros:

images (np.ndarray) : O array NumPy de entrada de imagens de profundidade, que pode ser uma única imagem ou um lote.

Retorna: list[PIL.Image.Image]

Uma lista de imagens PIL convertidas das imagens de profundidade NumPy de entrada.

Converte uma imagem de profundidade NumPy ou um lote de imagens em uma lista de imagens PIL.

numpy_to_pil[[diffusers.VaeImageProcessorLDM3D.numpy_to_pil]]

numpy_to_pil(images: ndarray)

Fonte

Parâmetros:

images (np.ndarray) : O array NumPy de entrada de imagens, que pode ser uma única imagem ou um lote.

Retorna: list[PIL.Image.Image]

Uma lista de imagens PIL convertidas do array NumPy de entrada.

Converte uma imagem NumPy ou um lote de imagens em uma lista de imagens PIL.

preprocess[[diffusers.VaeImageProcessorLDM3D.preprocess]]

preprocess(rgb: typing.Union[torch.Tensor, PIL.Image.Image, numpy.ndarray], depth: typing.Union[torch.Tensor, PIL.Image.Image, numpy.ndarray], height: int | None = None, width: int | None = None, target_res: int | None = None)

Fonte

Parâmetros:

rgb (torch.Tensor | PIL.Image.Image | np.ndarray) : A imagem de entrada RGB, que pode ser uma única imagem ou um lote.

depth (torch.Tensor | PIL.Image.Image | np.ndarray) : A imagem de profundidade de entrada, que pode ser uma única imagem ou um lote.

height (int | None, opcional, padrão None) : A altura desejada da imagem processada. Se None, o padrão é a altura da imagem de entrada.

width (int | None, opcional, padrão None) : A largura desejada da imagem processada. Se None, o padrão é a largura da imagem de entrada.

target_res (int | None, opcional, padrão None) : Resolução de destino para redimensionar as imagens. Se especificada, substitui a altura e a largura.

Retorna: tuple[torch.Tensor, torch.Tensor]

Uma tupla contendo as imagens RGB e de profundidade processadas como tensores do PyTorch.

Pré-processa a entrada de imagem. Os formatos aceitos são imagens PIL, arrays NumPy ou tensores PyTorch.

rgblike_to_depthmap[[diffusers.VaeImageProcessorLDM3D.rgblike_to_depthmap]]

rgblike_to_depthmap(image: typing.Union[numpy.ndarray, torch.Tensor])

Fonte

Converte uma imagem de profundidade em formato RGB para um mapa de profundidade.

PixArtImageProcessor[[diffusers.PixArtImageProcessor]]

diffusers.PixArtImageProcessor[[diffusers.PixArtImageProcessor]]

diffusers.PixArtImageProcessor(do_resize: bool = True, vae_scale_factor: int = 8, resample: str = 'lanczos', do_normalize: bool = True, do_binarize: bool = False, do_convert_grayscale: bool = False)

Fonte

Parâmetros:

do_resize (bool, opcional, padrão True) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de vae_scale_factor. Pode aceitar os argumentos height e width do método image_processor.VaeImageProcessor.preprocess().

vae_scale_factor (int, opcional, padrão 8) : Fator de escala do VAE. Se do_resize for True, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (str, opcional, padrão lanczos) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (bool, opcional, padrão True) : Se normalizar a imagem para [-1,1].

do_binarize (bool, opcional, padrão False) : Se deve binarizar a imagem para 0/1.

do_convert_rgb (bool, opcional, padrão é False) : Se as imagens devem ser convertidas para o formato RGB.

do_convert_grayscale (bool, opcional, padrão é False) : Se as imagens devem ser convertidas para o formato de escala de cinza.

Processador de imagem para redimensionar e recortar imagens do PixArt.

classify_height_width_bin[[diffusers.PixArtImageProcessor.classify_height_width_bin]]

classify_height_width_bin(height: int, width: int, ratios: dict)

Fonte

Parâmetros:

height (int) : A altura da imagem.

width (int) : A largura da imagem.

ratios (dict) : Um dicionário em que as chaves são as proporções de aspecto e os valores são tuplas de (altura, largura).

Retorna: tuple[int, int]

A altura e a largura mais próximas em bins.

Retorna a altura e a largura em intervalos com base na proporção de aspecto.

resize_and_crop_tensor[[diffusers.PixArtImageProcessor.resize_and_crop_tensor]]

resize_and_crop_tensor(samples: Tensor, new_width: int, new_height: int)

Fonte

Parâmetros:

samples (torch.Tensor) : Um tensor de forma (N, C, H, W), onde N é o tamanho do lote, C é o número de canais, H é a altura e W é a largura.

new_width (int) : A largura desejada das imagens de saída.

new_height (int) : A altura desejada das imagens de saída.

Retorna: torch.Tensor

Um tensor contendo as imagens redimensionadas e recortadas.

Redimensiona e recorta um tensor de imagens para as dimensões especificadas.

IPAdapterMaskProcessor[[diffusers.IPAdapterMaskProcessor]]

diffusers.IPAdapterMaskProcessor[[diffusers.IPAdapterMaskProcessor]]

diffusers.IPAdapterMaskProcessor(do_resize: bool = True, vae_scale_factor: int = 8, resample: str = 'lanczos', do_normalize: bool = False, do_binarize: bool = True, do_convert_grayscale: bool = True)

Fonte

Parâmetros:

do_resize (bool, opcional, padrão True) : Se as dimensões (altura, largura) da imagem devem ser reduzidas para múltiplos de vae_scale_factor.

vae_scale_factor (int, opcional, padrão 8) : Fator de escala do VAE. Se do_resize for True, a imagem será redimensionada automaticamente para múltiplos deste fator.

resample (str, opcional, padrão lanczos) : Filtro de reamostragem a ser usado ao redimensionar a imagem.

do_normalize (bool, opcional, padrão False) : Se normalizar a imagem para [-1,1].

do_binarize (bool, opcional, padrão True) : Se deve binarizar a imagem para 0/1.

do_convert_grayscale (bool, opcional, padrão é True) : Se as imagens devem ser convertidas para o formato de escala de cinza.

Processador de imagem para máscaras de imagem do IP Adapter.

downsample[[diffusers.IPAdapterMaskProcessor.downsample]]

downsample(mask: Tensor, batch_size: int, num_queries: int, value_embed_dim: int)

Fonte

Parâmetros:

mask (torch.Tensor) : O tensor de máscara de entrada gerado com IPAdapterMaskProcessor.preprocess().

batch_size (int) : O tamanho do lote.

num_queries (int) : O número de consultas.

value_embed_dim (int) : A dimensionalidade dos embeddings de valor.

Retorna: torch.Tensor

O tensor de máscara com amostragem reduzida.

Reduz a dimensão do tensor de máscara fornecido para corresponder às dimensões esperadas para a atenção de produto escalar. Se a proporção de aspecto da máscara não corresponder à proporção de aspecto da imagem de saída, um aviso é emitido.