Buckets:
| # DiT | |
| [Scalable Diffusion Models with Transformers](https://huggingface.co/papers/2212.09748) (DiT) é de William Peebles e Saining Xie. | |
| O resumo do artigo é: | |
| *Exploramos uma nova classe de modelos de difusão baseados na arquitetura de transformador. Treinamos modelos de difusão latente de imagens, substituindo o backbone U-Net comumente utilizado por um transformador que opera em patches latentes. Analisamos a escalabilidade dos nossos Diffusion Transformers (DiTs) pela lente da complexidade do forward pass, medida em Gflops. Descobrimos que DiTs com Gflops mais altos — por meio de aumento da profundidade/largura do transformador ou do número de tokens de entrada — consistentemente apresentam FID mais baixo. Além de possuir boas propriedades de escalabilidade, nossos maiores modelos DiT-XL/2 superam todos os modelos de difusão anteriores nos benchmarks class-conditional ImageNet 512x512 e 256x256, alcançando um FID state-of-the-art de 2.27 no último.* | |
| O código original pode ser encontrado em [facebookresearch/dit](https://github.com/facebookresearch/dit). | |
| > [!TIP] | |
| > Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines. | |
| ## DiTPipeline[[diffusers.DiTPipeline]] | |
| #### diffusers.DiTPipeline[[diffusers.DiTPipeline]] | |
| ```python | |
| diffusers.DiTPipeline(transformer: DiTTransformer2DModel, vae: AutoencoderKL, scheduler: KarrasDiffusionSchedulers, id2label: dict[int, str] | None = None) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/dit/pipeline_dit.py#L38) | |
| **Parâmetros:** | |
| transformer ([DiTTransformer2DModel](/docs/diffusers/main/pt/api/models/dit_transformer2d#diffusers.DiTTransformer2DModel)) : Uma classe condicionada `DiTTransformer2DModel` para desruidar os latentes da imagem codificada. Inicialmente publicada como [`Transformer2DModel`](https://huggingface.co/facebook/DiT-XL-2-256/blob/main/transformer/config.json#L2) na configuração, mas a incompatibilidade pode ser ignorada. | |
| vae ([AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes. | |
| scheduler ([DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. | |
| Pipeline para geração de imagens baseado em um backbone Transformer em vez de um UNet. | |
| Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.). | |
| #### __call__[[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) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/dit/pipeline_dit.py#L101) | |
| **Parâmetros:** | |
| class_labels (list[int]) : lista de rótulos de classes do ImageNet para as imagens a serem geradas. | |
| guidance_scale (`float`, *opcional*, padrão 4.0) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao `prompt` de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando `guidance_scale > 1`. | |
| generator (`torch.Generator`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. | |
| num_inference_steps (`int`, *opcional*, padrão 250) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. | |
| output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre `"pil"` (`PIL.Image`), `"np"` (`np.array`) ou `"pt"` (`torch.Tensor`). | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples. | |
| **Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple` | |
| Se `return_dict` for `True`, [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas | |
| A função de chamada do pipeline para geração. | |
| Exemplos: | |
| ```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]) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/dit/pipeline_dit.py#L76) | |
| **Parâmetros:** | |
| label (`str` ou `dict` de `str`) : Strings de rótulo a serem mapeadas para ids de classe. | |
| **Retorna:** `list` de `int` | |
| IDs de classes a serem processados pelo pipeline. | |
| Mapeia as strings de rótulos do ImageNet para os ids de classe correspondentes. | |
| ## ImagePipelineOutput[[diffusers.ImagePipelineOutput]] | |
| #### diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]] | |
| ```python | |
| diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L135) | |
| **Parâmetros:** | |
| images (`List[PIL.Image.Image]` ou `np.ndarray`) : Lista de imagens PIL desruídas de comprimento `batch_size` ou array NumPy de forma `(batch_size, height, width, num_channels)`. | |
| Classe de saída para pipelines de imagem. | |
Xet Storage Details
- Size:
- 6.92 kB
- Xet hash:
- b5f3278dec2f940ab94520bc7beefc6b83f6946460100087bead3adfdb105f22
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.