Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /es /api /image_processor.md
mishig
8 days ago
preview code
download
raw
27.1 kB
# Procesador de imágenes VAE

El [VaeImageProcessor](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessor) proporciona una API unificada para los [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) con el fin de preparar las entradas de imagen para la codificación con VAE y realizar el posprocesado de las salidas una vez que se han decodificado. Esto incluye transformaciones como el redimensionado, la normalización y la conversión entre imágenes PIL, PyTorch y matrices NumPy.

Todos los pipelines con [VaeImageProcessor](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessor) aceptan imágenes PIL, tensores de PyTorch o matrices de NumPy como entradas de imagen y devuelven salidas basadas en el argumento `output_type` del usuario. Puede pasar latentes de imagen codificados directamente al pipeline y obtener latentes del pipeline como una salida específica con el argumento `output_type` (por ejemplo, `output_type="latent"`). Esto le permite tomar los latentes generados de un pipeline y pasarlos a otro pipeline como entrada sin salir del espacio latente. También facilita mucho el uso de varios pipelines juntos al pasar tensores de PyTorch directamente entre diferentes 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)
```

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

**Parámetros:**

do_resize (`bool`, *opcional*, valor predeterminado `True`) : Si se deben reducir las dimensiones (altura, ancho) de la imagen a múltiplos de `vae_scale_factor`. Puede aceptar los argumentos `height` y `width` del método [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessor.preprocess).
vae_scale_factor (`int`, *opcional*, valor predeterminado `8`) : Factor de escala del VAE. Si `do_resize` es `True`, la imagen se redimensiona automáticamente a múltiplos de este factor.

resample (`str`, *opcional*, valor predeterminado `lanczos`) : Filtro de remuestreo que se utiliza al redimensionar la imagen.

do_normalize (`bool`, *opcional*, por defecto `True`) : Si se normaliza la imagen a [-1,1].
do_binarize (`bool`, *opcional*, por defecto `False`) : Si se debe binarizar la imagen a 0/1.

do_convert_rgb (`bool`, *opcional*, por defecto `False`) : Si se deben convertir las imágenes al formato RGB.

do_convert_grayscale (`bool`, *opcional*, por defecto `False`) : Si se deben convertir las imágenes al formato de escala de grises.

Procesador de imágenes para 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)
```

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

**Parámetros:**

mask (`PIL.Image.Image`) : La imagen de máscara que resalta las regiones a superponer.

init_image (`PIL.Image.Image`) : La imagen original a la que se aplica la superposición.
image (`PIL.Image.Image`) : La imagen que se superpondrá sobre la original.
crop_coords (`tuple[int, int, int, int]`, *opcional*) : Coordenadas para recortar la imagen. Si se proporcionan, la imagen se recortará en consecuencia.

**Devuelve:** `PIL.Image.Image`

La imagen final con la superposición aplicada.

Aplica una superposición de la máscara y la imagen reparada sobre la imagen original.

#### binarizar[[diffusers.VaeImageProcessor.binarize]]

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

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

**Parámetros:**

image (`PIL.Image.Image`) : La imagen de entrada, debe ser una imagen PIL.

**Devuelve:** `PIL.Image.Image`

La imagen binarizada. Los valores menores que 0.5 se establecen en 0, y los valores mayores que 0.5 se establecen en 1.

Crea una máscara.

#### blur[[diffusers.VaeImageProcessor.blur]]

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

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

**Parámetros:**

image (`PIL.Image.Image`) : La imagen de PIL que se convertirá a escala de grises.

**Devuelve:** `PIL.Image.Image`

La imagen PIL convertida a escala de grises.

Aplica un desenfoque gaussiano a una imagen.

#### convert_to_grayscale[[diffusers.VaeImageProcessor.convert_to_grayscale]]

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

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

**Parámetros:**

image (`PIL.Image.Image`) : La imagen de entrada a convertir.

**Devuelve:** `PIL.Image.Image`

La imagen convertida a escala de grises.

Convierte una imagen PIL dada a escala de grises.

#### convert_to_rgb[[diffusers.VaeImageProcessor.convert_to_rgb]]

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

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

**Parámetros:**

image (`PIL.Image.Image`) : La imagen de PIL que se convertirá a RGB.

**Devuelve:** `PIL.Image.Image`

La imagen PIL convertida a RGB.

Convierte una imagen PIL al formato RGB.

#### denormalizar[[diffusers.VaeImageProcessor.denormalize]]

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

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

**Parámetros:**

images (`np.ndarray` o `torch.Tensor`) : El array de imagen a denormalizar.

**Devuelve:** `np.ndarray` o `torch.Tensor`

El array de imagen denormalizado.

Denormalizar un array de imagen a [0,1].

#### get_crop_region[[diffusers.VaeImageProcessor.get_crop_region]]

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

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

**Parámetros:**

mask_image (PIL.Image.Image) : Imagen de máscara.
width (int) : Ancho de la imagen a procesar.
height (int) : Altura de la imagen a procesar.
pad (int, opcional) : Relleno que se añadirá a la región de recorte. El valor predeterminado es 0.
**Devuelve:** `tuple`
(x1, y1, x2, y2) representa una región rectangular que contiene todas las áreas enmascaradas de una imagen y coincide con la relación de aspecto original.
Encuentra una región rectangular que contenga todas las áreas enmascaradas de una imagen y expande la región para que coincida con la relación de aspecto de la imagen original; por ejemplo, si el usuario dibujó la máscara en una región de 128x32 y las dimensiones para el procesamiento son 512x512, la región se expandirá a 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L561)
**Parámetros:**
image (`PIL.Image.Image | np.ndarray | torch.Tensor`) : La entrada de imagen, que puede ser una imagen PIL, un array de NumPy o un tensor de PyTorch. Si es un array de NumPy, debe tener forma `[batch, height, width]` o `[batch, height, width, channels]`. Si es un tensor de PyTorch, debe tener forma `[batch, channels, height, width]`.
height (`int | None`, *opcional*, valor predeterminado `None`) : La altura de la imagen preprocesada. Si es `None`, se utilizará la altura de la entrada `image`.
width (`int | None`, *opcional*, valor predeterminado `None`) : El ancho de la imagen preprocesada. Si es `None`, se utilizará el ancho de la entrada `image`.
**Devuelve:** `tuple[int, int]`
Una tupla que contiene la altura y el ancho, ambos redimensionados al múltiplo entero más cercano de `vae_scale_factor`.
Devuelve la altura y el ancho de la imagen, reducidos al siguiente múltiplo entero de `vae_scale_factor`.
#### normalizar[[diffusers.VaeImageProcessor.normalize]]
```python
normalize(images: typing.Union[numpy.ndarray, torch.Tensor])
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L207)
**Parámetros:**
images (`np.ndarray` o `torch.Tensor`) : El array de imagen a normalizar.
**Devuelve:** `np.ndarray` o `torch.Tensor`
El array de imagen normalizado.
Normalizar un array de imagen a [-1,1].
#### numpy_to_pil[[diffusers.VaeImageProcessor.numpy_to_pil]]
```python
numpy_to_pil(images: ndarray)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L128)
**Parámetros:**
images (`np.ndarray`) : El array de imagen para convertir al formato PIL.
**Devuelve:** `list[PIL.Image.Image]`
Una lista de imágenes PIL.
Convierte una imagen de numpy o un lote de imágenes en una imagen de PIL.
#### numpy_to_pt[[diffusers.VaeImageProcessor.numpy_to_pt]]
```python
numpy_to_pt(images: ndarray)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L172)
**Parámetros:**
images (`np.ndarray`) : El array de imagen de NumPy que se convertirá al formato de PyTorch.
**Devuelve:** `torch.Tensor`
Una representación de las imágenes como tensor de PyTorch.
Convierte una imagen de NumPy en un tensor de PyTorch.
#### pil_to_numpy[[diffusers.VaeImageProcessor.pil_to_numpy]]
```python
pil_to_numpy(images: list[PIL.Image.Image] | PIL.Image.Image)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L152)
**Parámetros:**
images (`PIL.Image.Image` o `list[PIL.Image.Image]`) : La imagen PIL o lista de imágenes para convertir al formato NumPy.
**Devuelve:** `np.ndarray`
Una representación de las imágenes como un array de NumPy.
Convierte una imagen PIL o una lista de imágenes PIL en matrices NumPy.
#### postprocess[[diffusers.VaeImageProcessor.postprocess]]
```python
postprocess(image: Tensor, output_type: str = 'pil', do_denormalize: list[bool] | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L739)
**Parámetros:**
image (`torch.Tensor`) : La entrada de imagen, debe ser un tensor de pytorch con forma `B x C x H x W`.
output_type (`str`, *opcional*, por defecto `pil`) : El tipo de salida de la imagen, puede ser uno de `pil`, `np`, `pt`, `latent`.
do_denormalize (`list[bool]`, *opcional*, valor predeterminado `None`) : Si se debe desnormalizar la imagen a [0,1]. Si es `None`, se usará el valor de `do_normalize` en la configuración de `VaeImageProcessor`.
**Devuelve:** `PIL.Image.Image`, `np.ndarray` o `torch.Tensor`
La imagen procesada.
Postprocesa la imagen de salida de tensor a `output_type`.
#### preprocess[[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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L608)
**Parámetros:**
image (`PipelineImageInput`) : La entrada de imagen, los formatos aceptados son imágenes PIL, matrices NumPy, tensores de PyTorch; también se acepta una lista de formatos admitidos.
height (`int`, *opcional*) : La altura de la imagen preprocesada. Si es `None`, se usará `get_default_height_width()` para obtener la altura predeterminada.
width (`int`, *opcional*) : El ancho en preprocesado. Si es `None`, se usará get_default_height_width()` para obtener el ancho predeterminado.
resize_mode (`str`, *opcional*, valor predeterminado `default`) : El modo de redimensionado, puede ser `default` o `fill`. Si es `default`, se redimensionará la imagen para que quepa dentro del ancho y alto especificados, y es posible que no se mantenga la relación de aspecto original. Si es `fill`, se redimensionará la imagen para que quepa dentro del ancho y alto especificados, manteniendo la relación de aspecto, y luego se centrará la imagen dentro de las dimensiones, rellenando los espacios vacíos con datos de la imagen. Si es `crop`, se redimensionará la imagen para que quepa dentro del ancho y alto especificados, manteniendo la relación de aspecto, y luego se centrará la imagen dentro de las dimensiones, recortando el exceso. Tenga en cuenta que los modos de redimensionado `fill` y `crop` solo se admiten para entradas de imagen PIL.
crops_coords (`list[tuple[int, int, int, int]]`, *opcional*, valor predeterminado `None`) : Las coordenadas de recorte para cada imagen del lote. Si es `None`, no se recortará la imagen.
**Devuelve:** `torch.Tensor`
La imagen preprocesada.
Preprocesa la entrada de imagen.
#### pt_to_numpy[[diffusers.VaeImageProcessor.pt_to_numpy]]
```python
pt_to_numpy(images: Tensor)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L191)
**Parámetros:**
images (`torch.Tensor`) : El tensor de PyTorch que se convertirá al formato de NumPy.
**Devuelve:** `np.ndarray`
Una representación de las imágenes como un array de NumPy.
Convierte un tensor de PyTorch en una imagen de NumPy.
#### resize[[diffusers.VaeImageProcessor.resize]]
```python
resize(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], height: int, width: int, resize_mode: str = 'default')
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L463)
**Parámetros:**
image (`PIL.Image.Image`, `np.ndarray` o `torch.Tensor`) : La entrada de imagen, puede ser una imagen PIL, un array de numpy o un tensor de pytorch.
height (`int`) : La altura a la que se debe redimensionar.
width (`int`) : El ancho al que se debe redimensionar.
resize_mode (`str`, *opcional*, valor predeterminado `default`) : El modo de redimensionado a utilizar, puede ser `default` o `fill`. Si es `default`, se redimensionará la imagen para que quepa dentro del ancho y alto especificados, y es posible que no se mantenga la relación de aspecto original. Si es `fill`, se redimensionará la imagen para que quepa dentro del ancho y alto especificados, manteniendo la relación de aspecto, y luego se centrará la imagen dentro de las dimensiones, rellenando los espacios vacíos con datos de la imagen. Si es `crop`, se redimensionará la imagen para que quepa dentro del ancho y alto especificados, manteniendo la relación de aspecto, y luego se centrará la imagen dentro de las dimensiones, recortando el exceso. Tenga en cuenta que los modos de redimensionado `fill` y `crop` solo se admiten para entradas de imagen PIL.

**Devuelve:** `PIL.Image.Image`, `np.ndarray` o `torch.Tensor`

La imagen redimensionada.

Redimensionar imagen.

## InpaintProcessor[[diffusers.InpaintProcessor]]

El [InpaintProcessor](/docs/diffusers/main/es/api/image_processor#diffusers.InpaintProcessor) acepta las entradas `mask` y `image` y las procesa juntas. Opcionalmente, puede aceptar padding_mask_crop y aplicar una superposición de máscara.

#### 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)
```

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

Procesador de imágenes para inpainting de imagen y máscara.

#### 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)
```

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

Postprocesa la imagen y aplica opcionalmente una superposición de máscara

#### preprocess[[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)
```

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

Preprocesa la imagen y la máscara.

## VaeImageProcessorLDM3D[[diffusers.VaeImageProcessorLDM3D]]

El [VaeImageProcessorLDM3D](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessorLDM3D) acepta entradas RGB y de profundidad y devuelve salidas RGB y de profundidad.

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

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

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

**Parámetros:**

do_resize (`bool`, *opcional*, valor predeterminado `True`) : Si se deben reducir las dimensiones (altura, ancho) de la imagen a múltiplos de `vae_scale_factor`.
vae_scale_factor (`int`, *opcional*, valor predeterminado `8`) : Factor de escala del VAE. Si `do_resize` es `True`, la imagen se redimensiona automáticamente a múltiplos de este factor.

resample (`str`, *opcional*, valor predeterminado `lanczos`) : Filtro de remuestreo que se utiliza al redimensionar la imagen.

do_normalize (`bool`, *opcional*, por defecto `True`) : Si se normaliza la imagen a [-1,1].
Procesador de imágenes para 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1025)
**Parámetros:**
images (`list[PIL.Image.Image, PIL.Image.Image]`) : La imagen de entrada o lista de imágenes que se van a convertir.
**Devuelve:** `np.ndarray`
Un array de NumPy con las imágenes convertidas.
Convierte una imagen PIL o una lista de imágenes PIL en matrices NumPy.
#### numpy_to_depth[[diffusers.VaeImageProcessorLDM3D.numpy_to_depth]]
```python
numpy_to_depth(images: ndarray)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1083)
**Parámetros:**
images (`np.ndarray`) : El array de NumPy de entrada con imágenes de profundidad, que puede ser una sola imagen o un lote.
**Devuelve:** `list[PIL.Image.Image]`
Una lista de imágenes PIL convertidas desde las imágenes de profundidad de entrada de NumPy.
Convierte una imagen de profundidad de NumPy o un lote de imágenes en una lista de imágenes PIL.
#### numpy_to_pil[[diffusers.VaeImageProcessorLDM3D.numpy_to_pil]]
```python
numpy_to_pil(images: ndarray)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1001)
**Parámetros:**
images (`np.ndarray`) : El array de entrada de NumPy con las imágenes, que puede ser una sola imagen o un lote.
**Devuelve:** `list[PIL.Image.Image]`
Una lista de imágenes PIL convertidas desde la entrada de un array de NumPy.
Convierte una imagen de NumPy o un lote de imágenes en una lista de imágenes PIL.
#### preprocess[[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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/image_processor.py#L1161)
**Parámetros:**
rgb (`torch.Tensor | PIL.Image.Image | np.ndarray`) : La imagen de entrada RGB, que puede ser una sola imagen o un lote.
depth (`torch.Tensor | PIL.Image.Image | np.ndarray`) : La imagen de profundidad de entrada, que puede ser una sola imagen o un lote.
height (`int | None`, *opcional*, valor predeterminado `None`) : La altura deseada de la imagen procesada. Si es `None`, el valor predeterminado es la altura de la imagen de entrada.
width (`int | None`, *opcional*, valor predeterminado `None`) : El ancho deseado de la imagen procesada. Si es `None`, el valor predeterminado es el ancho de la imagen de entrada.
target_res (`int | None`, *opcional*, valor predeterminado `None`) : Resolución objetivo para redimensionar las imágenes. Si se especifica, reemplaza a height y width.

**Devuelve:** `tuple[torch.Tensor, torch.Tensor]`

Una tupla que contiene las imágenes RGB y de profundidad procesadas como tensores de PyTorch.

Preprocesa la entrada de imagen. Los formatos aceptados son imágenes PIL, matrices NumPy o tensores de PyTorch.

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

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

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

Convierte una imagen de profundidad similar a RGB en un mapa de profundidad.

## 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)
```

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

**Parámetros:**

do_resize (`bool`, *opcional*, valor predeterminado `True`) : Si se deben reducir las dimensiones (altura, ancho) de la imagen a múltiplos de `vae_scale_factor`. Puede aceptar los argumentos `height` y `width` del método [image_processor.VaeImageProcessor.preprocess()](/docs/diffusers/main/es/api/image_processor#diffusers.VaeImageProcessor.preprocess).
vae_scale_factor (`int`, *opcional*, valor predeterminado `8`) : Factor de escala del VAE. Si `do_resize` es `True`, la imagen se redimensiona automáticamente a múltiplos de este factor.

resample (`str`, *opcional*, valor predeterminado `lanczos`) : Filtro de remuestreo que se utiliza al redimensionar la imagen.

do_normalize (`bool`, *opcional*, por defecto `True`) : Si se normaliza la imagen a [-1,1].
do_binarize (`bool`, *opcional*, por defecto `False`) : Si se debe binarizar la imagen a 0/1.

do_convert_rgb (`bool`, *opcional*, por defecto `False`) : Si se deben convertir las imágenes al formato RGB.

do_convert_grayscale (`bool`, *opcional*, por defecto `False`) : Si se deben convertir las imágenes al formato de escala de grises.

Procesador de imágenes para redimensionar y recortar imágenes de PixArt.

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

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

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

**Parámetros:**

height (`int`) : La altura de la imagen.

width (`int`) : El ancho de la imagen.

ratios (`dict`) : Un diccionario donde las claves son relaciones de aspecto y los valores son tuplas de (altura, ancho).

**Devuelve:** `tuple[int, int]`

La altura y el ancho más cercanos en bins.

Devuelve la altura y el ancho binados en función de la relación de aspecto.

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

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

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

**Parámetros:**

samples (`torch.Tensor`) : Un tensor de forma (N, C, H, W) donde N es el tamaño del lote, C es el número de canales, H es la altura y W es el ancho.

new_width (`int`) : El ancho deseado de las imágenes de salida.
new_height (`int`) : La altura deseada de las imágenes de salida.

**Devuelve:** `torch.Tensor`

Un tensor que contiene las imágenes redimensionadas y recortadas.

Redimensiona y recorta un tensor de imágenes a las dimensiones especificadas.

## 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)
```

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

**Parámetros:**

do_resize (`bool`, *opcional*, valor predeterminado `True`) : Si se deben reducir las dimensiones (altura, ancho) de la imagen a múltiplos de `vae_scale_factor`.
vae_scale_factor (`int`, *opcional*, valor predeterminado `8`) : Factor de escala del VAE. Si `do_resize` es `True`, la imagen se redimensiona automáticamente a múltiplos de este factor.

resample (`str`, *opcional*, valor predeterminado `lanczos`) : Filtro de remuestreo que se utiliza al redimensionar la imagen.

do_normalize (`bool`, *opcional*, por defecto `False`) : Si se debe normalizar la imagen a [-1,1].
do_binarize (`bool`, *opcional*, por defecto `True`) : Si se debe binarizar la imagen a 0/1.

do_convert_grayscale (`bool`, *opcional*, por defecto `True`) : Si se deben convertir las imágenes al formato de escala de grises.

Procesador de imágenes para máscaras de imagen de IP Adapter.

#### downsample[[diffusers.IPAdapterMaskProcessor.downsample]]

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

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

**Parámetros:**

mask (`torch.Tensor`) : El tensor de máscara de entrada generado con `IPAdapterMaskProcessor.preprocess()`.

batch_size (`int`) : El tamaño del lote.
num_queries (`int`) : El número de consultas.

value_embed_dim (`int`) : La dimensionalidad de las incrustaciones de valor.

**Devuelve:** `torch.Tensor`

El tensor de máscara con muestreo descendente.

Realiza el downsampling del tensor de máscara proporcionado para que coincida con las dimensiones esperadas para la atención de producto punto escalado. Si la relación de aspecto de la máscara no coincide con la relación de aspecto de la imagen de salida, se emite una advertencia.
Xet Storage Details

Size:: 27.1 kB
Xet hash:: 42919cda3c2b85e6ec8eb7dfc331789972f15bc4146a4c80c93c38cc89530dcf
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.