diffusers/main/fr/api/image_processor.md

Processeur d'images VAE

Le VaeImageProcessor fournit une API unifiée pour les StableDiffusionPipeline afin de préparer les entrées d'images pour l'encodage VAE et de post-traiter les sorties une fois qu'elles sont décodées. Cela inclut des transformations telles que le redimensionnement, la normalisation et la conversion entre images PIL, tableaux PyTorch et tableaux NumPy.

Tous les pipelines utilisant VaeImageProcessor acceptent des images PIL, des tenseurs PyTorch ou des tableaux NumPy en entrée et retournent des sorties en fonction de l'argument output_type fourni par l'utilisateur. Vous pouvez transmettre directement des latents d'image encodés au pipeline et récupérer des latents en sortie via l'argument output_type (par exemple output_type="latent"). Cela permet de récupérer les latents générés par un pipeline et de les transmettre à un autre pipeline en entrée, sans quitter l'espace latent. Cela facilite également grandement l'utilisation de plusieurs pipelines ensemble en transmettant directement des tenseurs PyTorch entre les différents 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)

Source

Paramètres :

do_resize (bool, facultatif, par défaut True) : Indique s'il faut réduire les dimensions (hauteur, largeur) de l'image à des multiples de vae_scale_factor. Peut accepter les arguments height et width de la méthode image_processor.VaeImageProcessor.preprocess().

vae_scale_factor (int, facultatif, valeur par défaut 8) : facteur d'échelle du VAE. Si do_resize est True, l'image est redimensionnée automatiquement en multiples de ce facteur.

resample (str, facultatif, par défaut lanczos) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image.

do_normalize (bool, facultatif, par défaut True) : Indique s'il faut normaliser l'image dans l'intervalle [-1,1].

do_binarize (bool, facultatif, par défaut False) : Indique s'il faut binariser l'image en 0/1.

do_convert_rgb (bool, facultatif, valeur par défaut False) : Indique s'il faut convertir les images au format RGB.

do_convert_grayscale (bool, facultatif, valeur par défaut False) : Indique s'il faut convertir les images au format niveaux de gris.

Processeur d'images pour le 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)

Source

Paramètres :

mask (PIL.Image.Image) : L'image de masque qui met en évidence les régions à superposer.

init_image (PIL.Image.Image) : L'image d'origine sur laquelle le calque est appliqué.

image (PIL.Image.Image) : L'image à superposer sur l'image d'origine.

crop_coords (tuple[int, int, int, int], facultatif) : Coordonnées pour recadrer l'image. Si fournies, l'image sera recadrée en conséquence.

Retourne : PIL.Image.Image

L'image finale avec le calque appliqué.

Applique un calque du masque et de l'image retouchée sur l'image d'origine.

binarize[[diffusers.VaeImageProcessor.binarize]]

binarize(image: Image)

Source

Paramètres :

image (PIL.Image.Image) : l'image en entrée, doit être une image PIL.

Retourne : PIL.Image.Image

L'image binarisée. Les valeurs inférieures à 0,5 sont définies à 0, les valeurs supérieures à 0,5 sont définies à 1.

Créer un masque.

flou[[diffusers.VaeImageProcessor.blur]]

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

Source

Paramètres :

image (PIL.Image.Image) : L'image PIL à convertir en niveaux de gris.

Retourne : PIL.Image.Image

L'image PIL convertie en niveaux de gris.

Applique un flou gaussien à une image.

convert_to_grayscale[[diffusers.VaeImageProcessor.convert_to_grayscale]]

convert_to_grayscale(image: Image)

Source

Paramètres :

image (PIL.Image.Image) : L'image d'entrée à convertir.

Retourne : PIL.Image.Image

L'image convertie en niveaux de gris.

Convertit une image PIL donnée en niveaux de gris.

convert_to_rgb[[diffusers.VaeImageProcessor.convert_to_rgb]]

convert_to_rgb(image: Image)

Source

Paramètres :

image (PIL.Image.Image) : L'image PIL à convertir en RGB.

Retourne : PIL.Image.Image

L'image PIL convertie en RGB.

Convertit une image PIL au format RGB.

denormalize[[diffusers.VaeImageProcessor.denormalize]]

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

Source

Paramètres :

images (np.ndarray ou torch.Tensor) : Le tableau d'image à dénormaliser.

Retourne : np.ndarray ou torch.Tensor

Le tableau d'images dénormalisé.

Dénormaliser un tableau d'image vers [0,1].

get_crop_region[[diffusers.VaeImageProcessor.get_crop_region]]

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

Source

Paramètres :

mask_image (PIL.Image.Image) : Image de masque.

width (int) : Largeur de l'image à traiter.

height (int) : Hauteur de l'image à traiter.

pad (int, optionnel) : Rembourrage à ajouter à la zone de recadrage. Valeur par défaut : 0.

Retourne : tuple

(x1, y1, x2, y2) représente une zone rectangulaire qui contient toutes les zones masquées d'une image et qui correspond au ratio d'aspect d'origine.

Trouve une région rectangulaire contenant toutes les zones masquées d'une image, puis agrandit la région pour correspondre au ratio d'aspect de l'image d'origine ; par exemple, si l'utilisateur a dessiné un masque dans une région de 128x32 et que les dimensions de traitement sont 512x512, la région sera agrandie à 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)

Source

Paramètres :

image (PIL.Image.Image | np.ndarray | torch.Tensor) : L’entrée image, qui peut être une image PIL, un tableau NumPy ou un tenseur PyTorch. S’il s’agit d’un tableau NumPy, sa forme doit être [batch, height, width] ou [batch, height, width, channels]. S’il s’agit d’un tenseur PyTorch, sa forme doit être [batch, channels, height, width].

height (int | None, facultatif, valeur par défaut None) : La hauteur de l'image prétraitée. Si None, la hauteur de l'entrée image sera utilisée.

width (int | None, facultatif, valeur par défaut None) : La largeur de l'image prétraitée. Si None, la largeur de l'entrée image sera utilisée.

Retourne : tuple[int, int]

Un tuple contenant la hauteur et la largeur, toutes deux redimensionnées au multiple entier le plus proche de vae_scale_factor.

Retourne la hauteur et la largeur de l'image, redimensionnées au multiple entier supérieur de vae_scale_factor.

normalize[[diffusers.VaeImageProcessor.normalize]]

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

Source

Paramètres :

images (np.ndarray ou torch.Tensor) : Le tableau d'image à normaliser.

Retourne : np.ndarray ou torch.Tensor

Le tableau d'images normalisé.

Normaliser un tableau d'image dans l'intervalle [-1,1].

numpy_to_pil[[diffusers.VaeImageProcessor.numpy_to_pil]]

numpy_to_pil(images: ndarray)

Source

Paramètres :

images (np.ndarray) : Le tableau d'image à convertir au format PIL.

Retourne : list[PIL.Image.Image]

Une liste d'images PIL.

Convertir une image numpy ou un lot d'images en image PIL.

numpy_to_pt[[diffusers.VaeImageProcessor.numpy_to_pt]]

numpy_to_pt(images: ndarray)

Source

Paramètres :

images (np.ndarray) : Tableau d'image NumPy à convertir au format PyTorch.

Retourne : torch.Tensor

Représentation des images sous forme de tenseur PyTorch.

Convertir une image NumPy en tenseur PyTorch.

pil_to_numpy[[diffusers.VaeImageProcessor.pil_to_numpy]]

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

Source

Paramètres :

images (PIL.Image.Image ou list[PIL.Image.Image]) : L'image PIL ou la liste d'images à convertir au format NumPy.

Retourne : np.ndarray

Représentation des images sous forme de tableau NumPy.

Convertit une image PIL ou une liste d'images PIL en tableaux NumPy.

postprocess[[diffusers.VaeImageProcessor.postprocess]]

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

Source

Paramètres :

image (torch.Tensor) : L'entrée image, doit être un tenseur pytorch de forme B x C x H x W.

output_type (str, facultatif, par défaut pil) : Le type de sortie de l'image, peut être l'un des pil, np, pt, latent.

do_denormalize (list[bool], facultatif, par défaut None) : Indique s'il faut dénormaliser l'image vers [0,1]. Si None, utilise la valeur de do_normalize dans la configuration de VaeImageProcessor.

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

L'image après post-traitement.

Post-traitez l'image en sortie, de tensor vers output_type.

prétraiter[[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)

Source

Paramètres :

image (PipelineImageInput) : l'entrée image, les formats acceptés sont les images PIL, les tableaux NumPy, les tenseurs PyTorch ; accepte également une liste de formats pris en charge.

height (int, facultatif) : La hauteur de l'image prétraitée. Si None, la get_default_height_width() est utilisée pour obtenir la hauteur par défaut.

width (int, facultatif) : La largeur en prétraitement. Si None, utilisera get_default_height_width()` pour obtenir la largeur par défaut.

resize_mode (str, facultatif, valeur par défaut default) : Le mode de redimensionnement, peut être default ou fill. Si default, l’image est redimensionnée pour s’adapter à la largeur et à la hauteur spécifiées, sans nécessairement conserver le ratio d’aspect d’origine. Si fill, l’image est redimensionnée pour s’adapter à la largeur et à la hauteur spécifiées en conservant le ratio d’aspect, puis centrée dans les dimensions, les espaces vides étant remplis avec des données issues de l’image. Si crop, l’image est redimensionnée pour s’adapter à la largeur et à la hauteur spécifiées en conservant le ratio d’aspect, puis centrée dans les dimensions, l’excédent étant rogné. Notez que les modes de redimensionnement fill et crop ne sont pris en charge que pour une entrée d’image PIL.

crops_coords (list[tuple[int, int, int, int]], facultatif, valeur par défaut None) : Les coordonnées de recadrage pour chaque image du lot. Si None, l'image ne sera pas recadrée.

Retourne : torch.Tensor

L'image prétraitée.

Prétraitez l'entrée image.

pt_to_numpy[[diffusers.VaeImageProcessor.pt_to_numpy]]

pt_to_numpy(images: Tensor)

Source

Paramètres :

images (torch.Tensor) : Le tenseur PyTorch à convertir au format NumPy.

Retourne : np.ndarray

Représentation des images sous forme de tableau NumPy.

Convertir un tenseur PyTorch en image NumPy.

redimensionner[[diffusers.VaeImageProcessor.resize]]

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

Source

Paramètres :

image (PIL.Image.Image, np.ndarray ou torch.Tensor) : L'entrée image, peut être une image PIL, un tableau numpy ou un tenseur pytorch.

height (int) : La hauteur de redimensionnement.

width (int) : La largeur de redimensionnement.

resize_mode (str, facultatif, valeur par défaut default) : Le mode de redimensionnement à utiliser, peut être default ou fill. Si default, l'image est redimensionnée pour s'adapter à la largeur et à la hauteur spécifiées, sans nécessairement conserver le ratio d'aspect d'origine. Si fill, l'image est redimensionnée pour s'adapter à la largeur et à la hauteur spécifiées en conservant le ratio d'aspect, puis centrée dans les dimensions, les espaces vides étant remplis avec des données issues de l'image. Si crop, l'image est redimensionnée pour s'adapter à la largeur et à la hauteur spécifiées en conservant le ratio d'aspect, puis centrée dans les dimensions, l'excédent étant rogné. Notez que les modes de redimensionnement fill et crop ne sont pris en charge que pour les entrées d'images PIL.

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

L'image redimensionnée.

Redimensionner l'image.

InpaintProcessor[[diffusers.InpaintProcessor]]

Le InpaintProcessor accepte les entrées mask et image et les traite ensemble. Facultativement, il peut accepter padding_mask_crop et appliquer un calque de masque.

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)

Source

Processeur d'images pour l'inpainting d'une image et d'un masque.

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)

Source

Post-traiter l'image, appliquer éventuellement un masque en superposition

prétraiter[[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)

Source

Prétraitez l'image et le masque.

VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

Le VaeImageProcessorLDM3D accepte des entrées RGB et de profondeur et renvoie des sorties RGB et de profondeur.

diffusers.VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

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

Source

Paramètres :

do_resize (bool, facultatif, valeur par défaut True) : Indique s'il faut réduire les dimensions (hauteur, largeur) de l'image à des multiples de vae_scale_factor.

vae_scale_factor (int, facultatif, valeur par défaut 8) : facteur d'échelle du VAE. Si do_resize est True, l'image est redimensionnée automatiquement en multiples de ce facteur.

resample (str, facultatif, par défaut lanczos) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image.

do_normalize (bool, facultatif, par défaut True) : Indique s'il faut normaliser l'image dans l'intervalle [-1,1].

Processeur d'images pour VAE LDM3D.

depth_pil_to_numpy[[diffusers.VaeImageProcessorLDM3D.depth_pil_to_numpy]]

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

Source

Paramètres :

images (list[PIL.Image.Image, PIL.Image.Image]) : L'image d'entrée ou la liste d'images à convertir.

Retourne : np.ndarray

Un tableau NumPy des images converties.

Convertit une image PIL ou une liste d'images PIL en tableaux NumPy.

numpy_to_depth[[diffusers.VaeImageProcessorLDM3D.numpy_to_depth]]

numpy_to_depth(images: ndarray)

Source

Paramètres :

images (np.ndarray) : Tableau NumPy d'entrée contenant des images de profondeur, pouvant s'agir d'une image unique ou d'un lot.

Retourne : list[PIL.Image.Image]

Une liste d'images PIL converties à partir des images de profondeur NumPy d'entrée.

Convertir une image de profondeur NumPy ou un lot d'images en une liste d'images PIL.

numpy_to_pil[[diffusers.VaeImageProcessorLDM3D.numpy_to_pil]]

numpy_to_pil(images: ndarray)

Source

Paramètres :

images (np.ndarray) : Le tableau NumPy d'images en entrée, qui peut être une image unique ou un lot.

Retourne : list[PIL.Image.Image]

Une liste d'images PIL converties depuis le tableau NumPy d'entrée.

Convertir une image NumPy ou un lot d'images en une liste d'images PIL.

prétraiter[[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)

Source

Paramètres :

rgb (torch.Tensor | PIL.Image.Image | np.ndarray) : L'image d'entrée RGB, qui peut être une image unique ou un lot.

depth (torch.Tensor | PIL.Image.Image | np.ndarray) : L'image d'entrée de profondeur, qui peut être une image unique ou un lot.

height (int | None, facultatif, valeur par défaut None) : La hauteur souhaitée de l'image traitée. Si None, la valeur par défaut est la hauteur de l'image d'entrée.

width (int | None, facultatif, valeur par défaut None) : La largeur souhaitée de l'image traitée. Si None, la largeur de l'image d'entrée est utilisée par défaut.

target_res (int | None, facultatif, valeur par défaut None) : Résolution cible pour le redimensionnement des images. Si spécifiée, remplace la hauteur et la largeur.

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

Un tuple contenant les images RGB et de profondeur traitées sous forme de tenseurs PyTorch.

Prétraitez l’entrée image. Les formats acceptés sont les images PIL, les tableaux NumPy ou les tenseurs PyTorch.

rgblike_to_depthmap[[diffusers.VaeImageProcessorLDM3D.rgblike_to_depthmap]]

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

Source

Convertir une image de profondeur de type RGB en carte de profondeur.

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)

Source

Paramètres :

do_resize (bool, facultatif, par défaut True) : Indique s'il faut réduire les dimensions (hauteur, largeur) de l'image à des multiples de vae_scale_factor. Peut accepter les arguments height et width de la méthode image_processor.VaeImageProcessor.preprocess().

vae_scale_factor (int, facultatif, valeur par défaut 8) : facteur d'échelle du VAE. Si do_resize est True, l'image est redimensionnée automatiquement en multiples de ce facteur.

resample (str, facultatif, par défaut lanczos) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image.

do_normalize (bool, facultatif, par défaut True) : Indique s'il faut normaliser l'image dans l'intervalle [-1,1].

do_binarize (bool, facultatif, par défaut False) : Indique s'il faut binariser l'image en 0/1.

do_convert_rgb (bool, facultatif, valeur par défaut False) : Indique s'il faut convertir les images au format RGB.

do_convert_grayscale (bool, facultatif, valeur par défaut False) : Indique s'il faut convertir les images au format niveaux de gris.

Processeur d’images pour le redimensionnement et le recadrage des images PixArt.

classify_height_width_bin[[diffusers.PixArtImageProcessor.classify_height_width_bin]]

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

Source

Paramètres :

height (int) : La hauteur de l'image.

width (int) : La largeur de l'image.

ratios (dict) : Un dictionnaire dont les clés sont des rapports d'aspect et les valeurs des tuples de (hauteur, largeur).

Retourne : tuple[int, int]

La hauteur et la largeur binées les plus proches.

Retourne la hauteur et la largeur binées en fonction du ratio d'aspect.

resize_and_crop_tensor[[diffusers.PixArtImageProcessor.resize_and_crop_tensor]]

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

Source

Paramètres :

samples (torch.Tensor) : Un tenseur de forme (N, C, H, W) où N est la taille du lot, C est le nombre de canaux, H est la hauteur et W est la largeur.

new_width (int) : La largeur souhaitée des images de sortie.

new_height (int) : La hauteur souhaitée des images de sortie.

Retourne : torch.Tensor

Un tenseur contenant les images redimensionnées et recadrées.

Redimensionne et recadre un tenseur d'images aux dimensions spécifiées.

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)

Source

Paramètres :

do_resize (bool, facultatif, valeur par défaut True) : Indique s'il faut réduire les dimensions (hauteur, largeur) de l'image à des multiples de vae_scale_factor.

vae_scale_factor (int, facultatif, valeur par défaut 8) : facteur d'échelle du VAE. Si do_resize est True, l'image est redimensionnée automatiquement en multiples de ce facteur.

resample (str, facultatif, par défaut lanczos) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image.

do_normalize (bool, facultatif, par défaut False) : Indique s'il faut normaliser l'image dans l'intervalle [-1,1].

do_binarize (bool, facultatif, par défaut True) : Indique s'il faut binariser l'image en 0/1.

do_convert_grayscale (bool, facultatif, valeur par défaut True) : Indique s'il faut convertir les images au format niveaux de gris.

Processeur d'images pour les masques d'images IP Adapter.

downsample[[diffusers.IPAdapterMaskProcessor.downsample]]

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

Source

Paramètres :

mask (torch.Tensor) : Le tenseur de masque d'entrée généré avec IPAdapterMaskProcessor.preprocess().

batch_size (int) : La taille du lot.

num_queries (int) : Le nombre de requêtes.

value_embed_dim (int) : La dimensionnalité des embeddings de valeur.

Retourne : torch.Tensor

Le tenseur de masque sous-échantillonné.

Effectue un sous-échantillonnage du tenseur de masque fourni afin de correspondre aux dimensions attendues pour l'attention à produit scalaire mis à l'échelle. Si le rapport d'aspect du masque ne correspond pas au rapport d'aspect de l'image de sortie, un avertissement est émis.