Buckets:
| # DiT | |
| [Scalable Diffusion Models with Transformers](https://huggingface.co/papers/2212.09748) (DiT) est de William Peebles et Saining Xie. | |
| L'abstract de l'article est : | |
| *Nous explorons une nouvelle classe de modèles de diffusion basés sur l’architecture transformer. Nous entraînons des modèles de diffusion latente d’images, en remplaçant l’architecture U-Net couramment utilisée par un transformer qui opère sur des patches latents. Nous analysons la scalabilité de nos Diffusion Transformers (DiTs) à travers le prisme de la complexité du passage avant, mesurée en Gflops. Nous constatons que les DiTs ayant un nombre de Gflops plus élevé — grâce à une profondeur/largeur de transformer accrue ou à un nombre plus important de jetons d’entrée — présentent systématiquement un FID plus bas. En plus de posséder de bonnes propriétés de scalabilité, nos plus grands modèles DiT-XL/2 surpassent tous les modèles de diffusion antérieurs sur les benchmarks ImageNet 512x512 et 256x256 conditionnés par classe, atteignant un FID de pointe de 2,27 sur ce dernier.* | |
| Le code source original peut être trouvé sur [facebookresearch/dit](https://github.com/facebookresearch/dit). | |
| > [!TIP] | |
| > Pensez à consulter le [guide des Schedulers](../../using-diffusers/schedulers) pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section [réutilisation des composants entre les pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines. | |
| ## DiTPipeline[[diffusers.DiTPipeline]] | |
| #### diffusers.DiTPipeline[[diffusers.DiTPipeline]] | |
| ```python | |
| diffusers.DiTPipeline(transformer: DiTTransformer2DModel, vae: AutoencoderKL, scheduler: KarrasDiffusionSchedulers, id2label: dict[int, str] | None = None) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/dit/pipeline_dit.py#L38) | |
| **Paramètres :** | |
| transformer ([DiTTransformer2DModel](/docs/diffusers/main/fr/api/models/dit_transformer2d#diffusers.DiTTransformer2DModel)) : une classe conditionnée `DiTTransformer2DModel` pour débruyer les latents d'image encodés. Initialement publiée sous le nom [`Transformer2DModel`](https://huggingface.co/facebook/DiT-XL-2-256/blob/main/transformer/config.json#L2) dans la configuration, mais cette incohérence peut être ignorée. | |
| vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images vers et depuis des représentations latentes. | |
| scheduler ([DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler)) : Un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. | |
| Pipeline de génération d’images basé sur un backbone Transformer plutôt qu’un UNet. | |
| 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.DiTPipeline.__call__]] | |
| ```python | |
| __call__(class_labels: list[int], guidance_scale: float = 4.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, num_inference_steps: int = 50, output_type: str | None = 'pil', return_dict: bool = True) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/dit/pipeline_dit.py#L101) | |
| **Paramètres :** | |
| class_labels (list[int]) : liste des étiquettes de classes ImageNet pour les images à générer. | |
| guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Une valeur d'échelle de guidage plus élevée encourage le modèle à générer des images étroitement liées au `prompt` texte, au détriment de la qualité de l'image. L'échelle de guidage est activée lorsque `guidance_scale > 1`. | |
| generator (`torch.Generator`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe. | |
| num_inference_steps (`int`, *facultatif*, valeur par défaut 250) : 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. | |
| output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre `"pil"` (`PIL.Image`), `"np"` (`np.array`) ou `"pt"` (`torch.Tensor`). | |
| 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. | |
| **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 | |
| La fonction d'appel du pipeline pour la génération. | |
| Exemples : | |
| ```py | |
| >>> from diffusers import DiTPipeline, DPMSolverMultistepScheduler | |
| >>> import torch | |
| >>> pipe = DiTPipeline.from_pretrained("facebook/DiT-XL-2-256", torch_dtype=torch.float16) | |
| >>> pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) | |
| >>> pipe = pipe.to("cuda") | |
| >>> # pick words from Imagenet class labels | |
| >>> pipe.labels # to print all available words | |
| >>> # pick words that exist in ImageNet | |
| >>> words = ["white shark", "umbrella"] | |
| >>> class_ids = pipe.get_label_ids(words) | |
| >>> generator = torch.manual_seed(33) | |
| >>> output = pipe(class_labels=class_ids, num_inference_steps=25, generator=generator) | |
| >>> image = output.images[0] # label 'white shark' | |
| ``` | |
| #### get_label_ids[[diffusers.DiTPipeline.get_label_ids]] | |
| ```python | |
| get_label_ids(label: str | list[str]) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/dit/pipeline_dit.py#L76) | |
| **Paramètres :** | |
| label (`str` ou `dict` de `str`) : Chaînes de caractères des étiquettes à mapper vers les identifiants de classes. | |
| **Retourne :** `list` de `int` | |
| Identifiants de classes à traiter par le pipeline. | |
| Associer les chaînes de caractères des étiquettes d’ImageNet aux identifiants de classes correspondants. | |
| ## 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:
- 7.26 kB
- Xet hash:
- 300f60bf5e2813d3462c0eda84a25498690018a4b246488325589ba26d926d7e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.