# AutoencoderKLPH3Image

Le VAE d’images de [P-H3-Image](https://huggingface.co/PrunaAI/P-H3-Image) par Pruna AI. Il utilise l’encodeur et l’espace latent du [VAE vidéo](./autoencoderkl_minimax_h3) de MiniMax-H3, avec un décodeur ViT qui décode un seul cadre latent en image.

Elle suit les conventions de [AutoencoderKLMiniMaxH3](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_minimax_h3#diffusers.AutoencoderKLMiniMaxH3) :

- Les images sont transmises sous forme de vidéos à image unique, `(batch_size, channels, 1, height, width)`, avec une compression spatiale de 16x.
- Les latents sont normalisés par canal avec `latents_mean` / `latents_std` au lieu d'un `scaling_factor`.
- Les pixels sont des valeurs RGB normalisées par ImageNet sur `[0, 1]` : `encode` s'attend à `(pixel - imagenet_mean) / imagenet_std` et `decode` renvoie dans cet espace.
- Le tuilage spatial est activé par défaut, avec des tuiles de 256 pixels et au moins 64 pixels de chevauchement.

```python
import torch
from diffusers import AutoencoderKLPH3Image

vae = AutoencoderKLPH3Image.from_pretrained("PrunaAI/P-H3-Image", subfolder="vae", dtype=torch.bfloat16).to(
    "cuda"
)  # or "mps", "xpu", "cpu"
```

La projection de sortie de l'encodeur et du décodeur reste en float32, quel que soit le `dtype` dans lequel le modèle est chargé.

## AutoencoderKLPH3Image[[diffusers.AutoencoderKLPH3Image]]

#### diffusers.AutoencoderKLPH3Image[[diffusers.AutoencoderKLPH3Image]]

```python
diffusers.AutoencoderKLPH3Image(in_channels: int = 3, out_channels: int = 3, latent_channels: int = 24, block_out_channels: tuple[int, ...] = (128, 256, 256, 512, 512, 1024), layers_per_block: int = 2, spatial_downsample_factors: tuple[int, ...] = (2, 2, 2, 2, 1, 1), temporal_downsample_factors: tuple[int, ...] = (1, 2, 2, 1, 1, 1), norm_num_groups: int = 32, norm_eps: float = 1e-06, spatial_padding_mode: str = 'reflect', decoder_num_layers: int = 36, decoder_num_attention_heads: int = 32, decoder_attention_head_dim: int = 64, decoder_num_register_tokens: int = 4, decoder_ffn_mult: int = 4, decoder_rope_theta: float = 100.0, decoder_rope_dim_ratio: float = 0.75, decoder_norm_eps: float = 1e-05, latents_mean: tuple[float, ...] = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), latents_std: tuple[float, ...] = (1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0))
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_p_h3_image.py#L493)

Le VAE d’images de [P-H3-Image](https://huggingface.co/PrunaAI/P-H3-Image) : l’encodeur VAE et l’espace latent de MiniMax-H3, avec un `PH3ImageViTDecoder` qui décode une seule image latente.

Les images sont transmises sous forme de vidéos à image unique, `(batch_size, channels, 1, height, width)`. Comme dans [AutoencoderKLMiniMaxH3](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_minimax_h3#diffusers.AutoencoderKLMiniMaxH3), les pixels sont des valeurs RGB normalisées ImageNet sur `[0, 1]` (moyenne `(0.485, 0.456, 0.406)`, écart-type `(0.229, 0.224, 0.225)`) et le tuilage spatial est activé par défaut.

#### encode[[diffusers.AutoencoderKLPH3Image.encode]]

```python
encode(x: Tensor, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_p_h3_image.py#L728)

**Paramètres :**

x (`torch.Tensor`) : Lot d'images d'entrée en tant que vidéos à image unique, de forme `(batch_size, in_channels, 1, height, width)`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [AutoencoderKLOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.modeling_outputs.AutoencoderKLOutput) plutôt qu'un simple tuple.

**Retourne :**

La distribution latente des images encodées. Notez que les latents sont ensuite normalisés avec `latents_mean` / `latents_std`.

Encode un lot d'images en latents.

#### decode[[diffusers.AutoencoderKLPH3Image.decode]]

```python
decode(z: Tensor, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_p_h3_image.py#L757)

**Paramètres :**

z (`torch.Tensor`) : Lot d'entrée de latents, de forme `(batch_size, latent_channels, 1, height, width)`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) plutôt qu'un simple tuple.

**Retourne :** [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) ou `tuple`

Les images décodées, de forme `(batch_size, out_channels, 1, height, width)`.

Décoder un lot d'images latentes.

#### enable_tiling[[diffusers.AutoencoderKLPH3Image.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_sample_min_overlap_height: int | None = None, tile_sample_min_overlap_width: int | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_p_h3_image.py#L575)

**Paramètres :**

tile_sample_min_height (`int`, *facultatif*) : La hauteur de la tuile en espace pixel. Les images plus hautes que cette valeur sont divisées le long de la dimension de hauteur.

tile_sample_min_width (`int`, *facultatif*) : La largeur de la tuile en espace pixel. Les images plus larges que cette valeur sont divisées le long de la dimension de largeur.

tile_sample_min_overlap_height (`int`, *facultatif*) : Le chevauchement minimal, en pixels, entre deux tuiles verticales consécutives.

tile_sample_min_overlap_width (`int`, *facultatif*) : Le chevauchement minimal, en pixels, entre deux tuiles horizontales consécutives.

Active l’encodage/décodage VAE par tuiles. Lorsque cette option est activée, le VAE divise les images en tuiles, encode ou décode chaque tuile séparément, puis fusionne linéairement les zones de chevauchement. Cela réduit la consommation mémoire et permet de traiter des images de plus grande taille.

#### forward[[diffusers.AutoencoderKLPH3Image.forward]]

```python
forward(sample: Tensor, sample_posterior: bool = False, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_p_h3_image.py#L784)

**Paramètres :**

sample (`torch.Tensor`) : Lot d'images d'entrée en tant que vidéos à image unique, de forme `(batch_size, in_channels, 1, height, width)`.

sample_posterior (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut échantillonner la distribution a posteriori plutôt que de prendre son mode.

generator (`torch.Generator`, *facultatif*) : Générateur utilisé lorsque `sample_posterior=True`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) plutôt qu'un simple tuple.

**Retourne :** [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) ou `tuple`

Les images après aller-retour, de forme `(batch_size, out_channels, 1, height, width)`.

Encoder puis décoder un lot d'images.