Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /v0.43.0 /fr /api /models /consistency_decoder_vae.md

mishig

about 3 hours ago

preview code

download

raw

7.07 kB

# Décodeur de cohérence

Le décodeur de cohérence peut être utilisé pour décoder les latents issus du UNet de débruitage dans le [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline). Ce décodeur a été introduit dans le [rapport technique de DALL-E 3](https://openai.com/dall-e-3).

Le code source original peut être trouvé sur [openai/consistencydecoder](https://github.com/openai/consistencydecoder).

> [!WARNING]
> L'inférence n'est actuellement prise en charge que pour 2 itérations.

Le pipeline n'aurait pas pu être contribué sans l'aide de [madebyollin](https://github.com/madebyollin) et [mrsteyk](https://github.com/mrsteyk) de [cet issue](https://github.com/openai/consistencydecoder/issues/1).

## ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

#### diffusers.ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

```python
diffusers.ConsistencyDecoderVAE(scaling_factor: float = 0.18215, latent_channels: int = 4, sample_size: int = 32, encoder_act_fn: str = 'silu', encoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512), encoder_double_z: bool = True, encoder_down_block_types: tuple[str, ...] = ('DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'), encoder_in_channels: int = 3, encoder_layers_per_block: int = 2, encoder_norm_num_groups: int = 32, encoder_out_channels: int = 4, decoder_add_attention: bool = False, decoder_block_out_channels: tuple[int, ...] = (320, 640, 1024, 1024), decoder_down_block_types: tuple[str, ...] = ('ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D'), decoder_downsample_padding: int = 1, decoder_in_channels: int = 7, decoder_layers_per_block: int = 3, decoder_norm_eps: float = 1e-05, decoder_norm_num_groups: int = 32, decoder_num_train_timesteps: int = 1024, decoder_out_channels: int = 6, decoder_resnet_time_scale_shift: str = 'scale_shift', decoder_time_embedding_type: str = 'learned', decoder_up_block_types: tuple[str, ...] = ('ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D'))
```

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

Le décodeur de cohérence utilisé avec DALL-E 3.

Exemples :
```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline, ConsistencyDecoderVAE
>>> vae = ConsistencyDecoderVAE.from_pretrained("openai/consistency-decoder", torch_dtype=torch.float16)
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", vae=vae, torch_dtype=torch.float16
... ).to("cuda")
>>> image = pipe("horse", generator=torch.manual_seed(0)).images[0]
>>> image
```

#### decode[[diffusers.ConsistencyDecoderVAE.decode]]

```python
decode(z: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True, num_inference_steps: int = 2)
```

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

**Paramètres :**

z (torch.Tensor) : Le vecteur latent d'entrée.

generator (torch.Generator | None) : Le générateur de nombres aléatoires. La valeur par défaut est None.

return_dict (bool) : Indique s'il faut renvoyer la sortie sous forme de dictionnaire. La valeur par défaut est True.
num_inference_steps (int) : Le nombre d'étapes d'inférence. La valeur par défaut est 2.
**Retourne :** DecoderOutput | tuple[torch.Tensor]
La sortie décodée.
Décode le vecteur latent d’entrée `z` à l’aide du modèle VAE du décodeur de cohérence.
#### encode[[diffusers.ConsistencyDecoderVAE.encode]]
```python
encode(x: Tensor, return_dict: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L185)
**Paramètres :**
x (`torch.Tensor`) : Lot d'images en entrée.
return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `ConsistencyDecoderVAEOutput` plutôt qu'un simple tuple.
**Retourne :**
Les représentations latentes des images encodées. Si `return_dict` est True, un `ConsistencyDecoderVAEOutput` est renvoyé, sinon un simple `tuple` est renvoyé.
Encode un lot d'images en latents.
#### forward[[diffusers.ConsistencyDecoderVAE.forward]]
```python
forward(sample: Tensor, sample_posterior: bool = False, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L336)
**Paramètres :**
sample (`torch.Tensor`) : Échantillon d'entrée.
sample_posterior (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut échantillonner à partir de la distribution a posteriori.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `DecoderOutput` plutôt qu'un simple tuple.
generator (`torch.Generator`, *facultatif*, par défaut `None`) : Générateur à utiliser pour l'échantillonnage.
**Retourne :** `DecoderOutput` ou `tuple`
If return_dict is True, a `DecoderOutput` is returned, otherwise a plain `tuple` is returned.
#### set_default_attn_processor[[diffusers.ConsistencyDecoderVAE.set_default_attn_processor]]
```python
set_default_attn_processor()
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L170)
Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut.
#### tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]
```python
tiled_encode(x: Tensor, return_dict: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L281)
**Paramètres :**
x (`torch.Tensor`) : Lot d'images en entrée.
return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `ConsistencyDecoderVAEOutput` plutôt qu'un simple tuple.

**Retourne :** `ConsistencyDecoderVAEOutput` ou `tuple`

If return_dict is True, a `ConsistencyDecoderVAEOutput` is returned, otherwise a plain `tuple` is returned.
Encoder un lot d'images à l'aide d'un encodeur tuilé.
Lorsque cette option est activée, le VAE divise le tenseur d’entrée en tuiles pour calculer l’encodage en plusieurs étapes. Cela est utile pour maintenir une utilisation de la mémoire constante, indépendamment de la taille de l’image. Le résultat final de l’encodage par tuiles diffère de celui de l’encodage non tuilé, car chaque tuile utilise un encodeur différent. Pour éviter les artefacts de tuilage, les tuiles se chevauchent et sont fusionnées pour former une sortie lisse. Vous pouvez encore observer des variations de la taille des tuiles dans la sortie, mais elles devraient être beaucoup moins perceptibles.

Xet Storage Details

Size:: 7.07 kB
Xet hash:: 8cfa4cfc27a57dce8527854951c8f3d806bb68973ec2351355be1a3bc4f5d462

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# Décodeur de cohérence

	Le décodeur de cohérence peut être utilisé pour décoder les latents issus du UNet de débruitage dans le [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline). Ce décodeur a été introduit dans le [rapport technique de DALL-E 3](https://openai.com/dall-e-3).

	Le code source original peut être trouvé sur [openai/consistencydecoder](https://github.com/openai/consistencydecoder).

	> [!WARNING]
	> L'inférence n'est actuellement prise en charge que pour 2 itérations.

	Le pipeline n'aurait pas pu être contribué sans l'aide de [madebyollin](https://github.com/madebyollin) et [mrsteyk](https://github.com/mrsteyk) de [cet issue](https://github.com/openai/consistencydecoder/issues/1).

	## ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

	#### diffusers.ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

	```python
	diffusers.ConsistencyDecoderVAE(scaling_factor: float = 0.18215, latent_channels: int = 4, sample_size: int = 32, encoder_act_fn: str = 'silu', encoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512), encoder_double_z: bool = True, encoder_down_block_types: tuple[str, ...] = ('DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'), encoder_in_channels: int = 3, encoder_layers_per_block: int = 2, encoder_norm_num_groups: int = 32, encoder_out_channels: int = 4, decoder_add_attention: bool = False, decoder_block_out_channels: tuple[int, ...] = (320, 640, 1024, 1024), decoder_down_block_types: tuple[str, ...] = ('ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D'), decoder_downsample_padding: int = 1, decoder_in_channels: int = 7, decoder_layers_per_block: int = 3, decoder_norm_eps: float = 1e-05, decoder_norm_num_groups: int = 32, decoder_num_train_timesteps: int = 1024, decoder_out_channels: int = 6, decoder_resnet_time_scale_shift: str = 'scale_shift', decoder_time_embedding_type: str = 'learned', decoder_up_block_types: tuple[str, ...] = ('ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D'))
	```

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

	Le décodeur de cohérence utilisé avec DALL-E 3.

	Exemples :
	```py
	>>> import torch
	>>> from diffusers import StableDiffusionPipeline, ConsistencyDecoderVAE

	>>> vae = ConsistencyDecoderVAE.from_pretrained("openai/consistency-decoder", torch_dtype=torch.float16)
	>>> pipe = StableDiffusionPipeline.from_pretrained(
	... "stable-diffusion-v1-5/stable-diffusion-v1-5", vae=vae, torch_dtype=torch.float16
	... ).to("cuda")

	>>> image = pipe("horse", generator=torch.manual_seed(0)).images[0]
	>>> image
	```

	#### decode[[diffusers.ConsistencyDecoderVAE.decode]]

	```python
	decode(z: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True, num_inference_steps: int = 2)
	```

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

	Paramètres :

	z (torch.Tensor) : Le vecteur latent d'entrée.

	generator (torch.Generator \| None) : Le générateur de nombres aléatoires. La valeur par défaut est None.

	return_dict (bool) : Indique s'il faut renvoyer la sortie sous forme de dictionnaire. La valeur par défaut est True.

	num_inference_steps (int) : Le nombre d'étapes d'inférence. La valeur par défaut est 2.

	Retourne : DecoderOutput \| tuple[torch.Tensor]

	La sortie décodée.

	Décode le vecteur latent d’entrée `z` à l’aide du modèle VAE du décodeur de cohérence.

	#### encode[[diffusers.ConsistencyDecoderVAE.encode]]

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

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

	Paramètres :

	x (`torch.Tensor`) : Lot d'images en entrée.

	return_dict (`bool`, facultatif, valeur par défaut `True`) : Indique s'il faut retourner un `ConsistencyDecoderVAEOutput` plutôt qu'un simple tuple.

	Retourne :

	Les représentations latentes des images encodées. Si `return_dict` est True, un `ConsistencyDecoderVAEOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

	Encode un lot d'images en latents.

	#### forward[[diffusers.ConsistencyDecoderVAE.forward]]

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

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

	Paramètres :

	sample (`torch.Tensor`) : Échantillon d'entrée.

	sample_posterior (`bool`, facultatif, par défaut `False`) : Indique s'il faut échantillonner à partir de la distribution a posteriori.

	return_dict (`bool`, facultatif, par défaut `True`) : Indique s'il faut retourner un `DecoderOutput` plutôt qu'un simple tuple.

	generator (`torch.Generator`, facultatif, par défaut `None`) : Générateur à utiliser pour l'échantillonnage.

	Retourne : `DecoderOutput` ou `tuple`

	If return_dict is True, a `DecoderOutput` is returned, otherwise a plain `tuple` is returned.

	#### set_default_attn_processor[[diffusers.ConsistencyDecoderVAE.set_default_attn_processor]]

	```python
	set_default_attn_processor()
	```

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

	Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut.

	#### tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]

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

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

	Paramètres :

	x (`torch.Tensor`) : Lot d'images en entrée.

	return_dict (`bool`, facultatif, valeur par défaut `True`) : Indique s'il faut retourner un `ConsistencyDecoderVAEOutput` plutôt qu'un simple tuple.

	Retourne : `ConsistencyDecoderVAEOutput` ou `tuple`

	If return_dict is True, a `ConsistencyDecoderVAEOutput` is returned, otherwise a plain `tuple` is returned.

	Encoder un lot d'images à l'aide d'un encodeur tuilé.

	Lorsque cette option est activée, le VAE divise le tenseur d’entrée en tuiles pour calculer l’encodage en plusieurs étapes. Cela est utile pour maintenir une utilisation de la mémoire constante, indépendamment de la taille de l’image. Le résultat final de l’encodage par tuiles diffère de celui de l’encodage non tuilé, car chaque tuile utilise un encodeur différent. Pour éviter les artefacts de tuilage, les tuiles se chevauchent et sont fusionnées pour former une sortie lisse. Vous pouvez encore observer des variations de la taille des tuiles dans la sortie, mais elles devraient être beaucoup moins perceptibles.