Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /fr /api /image_processor.md
mishig
8 days ago
preview code
download
raw
27.2 kB
# Processeur d'images VAE

Le [VaeImageProcessor](/docs/diffusers/main/fr/api/image_processor#diffusers.VaeImageProcessor) fournit une API unifiée pour les [StableDiffusionPipeline](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/text2img#diffusers.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](/docs/diffusers/main/fr/api/image_processor#diffusers.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]]

```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L83)

**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()](/docs/diffusers/main/fr/api/image_processor#diffusers.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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L789)

**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]]

```python
binarize(image: Image)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L524)

**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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L271)

**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]]

```python
convert_to_grayscale(image: Image)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L254)

**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]]

```python
convert_to_rgb(image: Image)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L237)

**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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L222)

**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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L288)

**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]]
```python
get_default_height_width(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int | None = None, width: int | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L561)
**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]]
```python
normalize(images: typing.Union[numpy.ndarray, torch.Tensor])
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L207)
**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]]
```python
numpy_to_pil(images: ndarray)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L128)
**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]]
```python
numpy_to_pt(images: ndarray)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L172)
**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]]
```python
pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L152)
**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]]
```python
postprocess(image: Tensor, output_type: str = 'pil', do_denormalize: list[bool] | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L739)
**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]]
```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L608)
**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]]
```python
pt_to_numpy(images: Tensor)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L191)
**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]]
```python
resize(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int, width: int, resize_mode: str = 'default')
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L463)
**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](/docs/diffusers/main/fr/api/image_processor#diffusers.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]]

```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L837)

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

#### postprocess[[diffusers.InpaintProcessor.postprocess]]

```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L944)

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

#### prétraiter[[diffusers.InpaintProcessor.preprocess]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L882)

Prétraitez l'image et le masque.

## VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

Le [VaeImageProcessorLDM3D](/docs/diffusers/main/fr/api/image_processor#diffusers.VaeImageProcessorLDM3D) accepte des entrées RGB et de profondeur et renvoie des sorties RGB et de profondeur.

#### diffusers.VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L974)

**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]]
```python
depth_pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1025)
**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]]
```python
numpy_to_depth(images: ndarray)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1083)
**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]]
```python
numpy_to_pil(images: ndarray)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1001)
**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]]
```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1161)
**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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1045)

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

## PixArtImageProcessor[[diffusers.PixArtImageProcessor]]

#### diffusers.PixArtImageProcessor[[diffusers.PixArtImageProcessor]]

```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1381)

**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()](/docs/diffusers/main/fr/api/image_processor#diffusers.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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1422)

**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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1440)

**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]]

```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1277)

**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]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1318)

**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.
Xet Storage Details

Size:: 27.2 kB
Xet hash:: 249e86a777f8258a6a0e3ad4bcf5e160f1c3621f3a4cead3cbd0caff6f708ea6
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.