diffusers/main/fr/api/pipelines/consistency_models.md

Modèles de cohérence

Les Consistency Models ont été proposés dans Consistency Models par Yang Song, Prafulla Dhariwal, Mark Chen et Ilya Sutskever.

L'abstract de l'article est :

Les modèles de diffusion ont considérablement fait progresser les domaines de la génération d’images, d’audio et de vidéo, mais ils reposent sur un processus d’échantillonnage itératif qui entraîne une génération lente. Pour surmonter cette limitation, nous proposons les modèles de cohérence, une nouvelle famille de modèles qui génèrent des échantillons de haute qualité en cartographiant directement le bruit vers les données. Ils prennent en charge la génération rapide en une étape par conception, tout en permettant un échantillonnage multi-étapes pour échanger le calcul contre la qualité des échantillons. Ils prennent également en charge l’édition de données en zéro tirage, comme l’interpolation d’images, la colorisation et la super-résolution, sans nécessiter d’entraînement explicite sur ces tâches. Les modèles de cohérence peuvent être entraînés soit en distillant des modèles de diffusion pré-entraînés, soit comme des modèles génératifs autonomes. À travers des expériences exhaustives, nous démontrons qu’ils surpassent les techniques de distillation existantes pour les modèles de diffusion en échantillonnage en une ou quelques étapes, atteignant le nouvel état de l’art avec un FID de 3,55 sur CIFAR-10 et 6,20 sur ImageNet 64x64 pour la génération en une étape. Lorsqu’ils sont entraînés de manière isolée, les modèles de cohérence deviennent une nouvelle famille de modèles génératifs qui peuvent surpasser les modèles génératifs existants en une étape et non adversariaux sur des benchmarks standard tels que CIFAR-10, ImageNet 64x64 et LSUN 256x256.

Le code source original peut être trouvé sur openai/consistency_models, et des points de contrôle supplémentaires sont disponibles sur openai.

Le pipeline a été contribué par dg845 et ayushtues. ❤️

Astuces

Pour un gain de vitesse supplémentaire, utilisez torch.compile pour générer plusieurs images en moins d'une seconde :

  import torch
  from diffusers import ConsistencyModelPipeline

  device = "cuda"  # or "mps", "xpu", "cpu"
  # Load the cd_bedroom256_lpips checkpoint.
  model_id_or_path = "openai/diffusers-cd_bedroom256_lpips"
  pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, dtype=torch.float16)
  pipe.to(device)

+ pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

  # Multistep sampling
  # Timesteps can be explicitly specified; the particular timesteps below are from the original GitHub repo:
  # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L83
  for _ in range(10):
      image = pipe(timesteps=[17, 0]).images[0]
      image.show()

ConsistencyModelPipeline[[diffusers.ConsistencyModelPipeline]]

diffusers.ConsistencyModelPipeline[[diffusers.ConsistencyModelPipeline]]

diffusers.ConsistencyModelPipeline(unet: UNet2DModel, scheduler: CMStochasticIterativeScheduler)

Source

Paramètres :

unet (UNet2DModel) : Un UNet2DModel pour débruyer les latents d'image encodés.

scheduler (SchedulerMixin) : Un planificateur à utiliser en combinaison avec unet pour débruyer les latents de l'image encodée. Actuellement, il n'est compatible qu'avec CMStochasticIterativeScheduler.

Pipeline pour la génération d'images non conditionnelle ou conditionnelle par classe.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

appel[[diffusers.ConsistencyModelPipeline.call]]

__call__(batch_size: int = 1, class_labels: typing.Union[torch.Tensor, list[int], int, NoneType] = None, num_inference_steps: int = 1, timesteps: list[int] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1)

Source

Paramètres :

batch_size (int, facultatif, par défaut 1) : Le nombre d'images à générer.

class_labels (torch.Tensor ou list[int] ou int, facultatif) : Étiquettes de classe facultatives pour conditionner les modèles de cohérence conditionnels par classe. Non utilisées si le modèle n'est pas conditionnel par classe.

num_inference_steps (int, facultatif, valeur par défaut 1) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

timesteps (list[int], facultatif) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps num_inference_steps équidistantes sont utilisées. Doivent être dans l'ordre décroissant.

generator (torch.Generator, facultatif) : Un torch.Generator pour rendre la génération déterministe.

latents (torch.Tensor, facultatif) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du generator aléatoire fourni.

output_type (str, facultatif, par défaut "pil") : Le format de sortie de l'image générée. Choisissez entre PIL.Image ou np.array.

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

callback (Callable, facultatif) : une fonction appelée toutes les callback_steps étapes pendant l'inférence. La fonction est appelée avec les arguments suivants : callback(step: int, timestep: int, latents: torch.Tensor).

callback_steps (int, facultatif, valeur par défaut 1) : La fréquence à laquelle la fonction callback est appelée. Si non spécifié, le callback est appelé à chaque étape.

Retourne : ImagePipelineOutput ou tuple

Si return_dict est True, ImagePipelineOutput est retourné, sinon un tuple est retourné dont le premier élément est une liste contenant les images générées.

Exemples :

>>> import torch

>>> from diffusers import ConsistencyModelPipeline

>>> device = "cuda"
>>> # Load the cd_imagenet64_l2 checkpoint.
>>> model_id_or_path = "openai/diffusers-cd_imagenet64_l2"
>>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
>>> pipe.to(device)

>>> # Onestep Sampling
>>> image = pipe(num_inference_steps=1).images[0]
>>> image.save("cd_imagenet64_l2_onestep_sample.png")

>>> # Onestep sampling, class-conditional image generation
>>> # ImageNet-64 class label 145 corresponds to king penguins
>>> image = pipe(num_inference_steps=1, class_labels=145).images[0]
>>> image.save("cd_imagenet64_l2_onestep_sample_penguin.png")

>>> # Multistep sampling, class-conditional image generation
>>> # Timesteps can be explicitly specified; the particular timesteps below are from the original GitHub repo:
>>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77
>>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]
>>> image.save("cd_imagenet64_l2_multistep_sample_penguin.png")

ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)

Source

Paramètres :

images (List[PIL.Image.Image] ou np.ndarray) : Liste d'images PIL débruitées de longueur batch_size ou tableau NumPy de forme (batch_size, height, width, num_channels).

Classe de sortie pour les pipelines d’images.