Buckets:
| # Modèles de cohérence | |
| Les Consistency Models ont été proposés dans [Consistency Models](https://huggingface.co/papers/2303.01469) 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](https://github.com/openai/consistency_models), et des points de contrôle supplémentaires sont disponibles sur [openai](https://huggingface.co/openai). | |
| Le pipeline a été contribué par [dg845](https://github.com/dg845) et [ayushtues](https://huggingface.co/ayushtues). ❤️ | |
| ## Astuces | |
| Pour un gain de vitesse supplémentaire, utilisez `torch.compile` pour générer plusieurs images en moins d'une seconde : | |
| ```diff | |
| 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]] | |
| ```python | |
| diffusers.ConsistencyModelPipeline(unet: UNet2DModel, scheduler: CMStochasticIterativeScheduler) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/consistency_models/pipeline_consistency_models.py#L67) | |
| **Paramètres :** | |
| unet ([UNet2DModel](/docs/diffusers/main/fr/api/models/unet2d#diffusers.UNet2DModel)) : Un `UNet2DModel` pour débruyer les latents d'image encodés. | |
| scheduler ([SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.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](/docs/diffusers/main/fr/api/schedulers/cm_stochastic_iterative#diffusers.CMStochasticIterativeScheduler). | |
| Pipeline pour la génération d'images non conditionnelle ou conditionnelle par classe. | |
| Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.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__]] | |
| ```python | |
| __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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/consistency_models/pipeline_consistency_models.py#L171) | |
| **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`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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](/docs/diffusers/main/fr/api/pipelines/consistency_models#diffusers.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](/docs/diffusers/main/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple` | |
| Si `return_dict` est `True`, [ImagePipelineOutput](/docs/diffusers/main/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les images générées. | |
| Exemples : | |
| ```py | |
| >>> 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]] | |
| ```python | |
| diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L135) | |
| **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. | |
Xet Storage Details
- Size:
- 9.47 kB
- Xet hash:
- 906b7c74018ba495016a7f740523f161509bd102cca0aa2478a94a81ee23d573
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.