Buckets:
| # DiT | |
| [Scalable Diffusion Models with Transformers](https://huggingface.co/papers/2212.09748) (DiT) es de William Peebles y Saining Xie. | |
| El resumen del artículo es: | |
| *Exploramos una nueva clase de modelos de difusión basados en la arquitectura transformer. Entrenamos modelos de difusión latente de imágenes, reemplazando el backbone U-Net comúnmente utilizado por un transformer que opera sobre parches latentes. Analizamos la escalabilidad de nuestros Diffusion Transformers (DiTs) a través de la complejidad de la pasada hacia adelante medida en Gflops. Encontramos que los DiTs con más Gflops, ya sea mediante un aumento de la profundidad/ancho del transformer o un mayor número de tokens de entrada, tienen consistentemente un FID más bajo. Además de poseer buenas propiedades de escalabilidad, nuestros modelos DiT-XL/2 más grandes superan a todos los modelos de difusión anteriores en los benchmarks de ImageNet 512x512 y 256x256 condicionados por clase, logrando un FID del estado del arte de 2.27 en este último.* | |
| El código original se puede encontrar en [facebookresearch/dit](https://github.com/facebookresearch/dit). | |
| > [!TIP] | |
| > Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines. | |
| ## DiTPipeline[[diffusers.DiTPipeline]] | |
| #### diffusers.DiTPipeline[[diffusers.DiTPipeline]] | |
| ```python | |
| diffusers.DiTPipeline(transformer: DiTTransformer2DModel, vae: AutoencoderKL, scheduler: KarrasDiffusionSchedulers, id2label: dict[int, str] | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/dit/pipeline_dit.py#L38) | |
| **Parámetros:** | |
| transformer ([DiTTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/dit_transformer2d#diffusers.DiTTransformer2DModel)) : Una clase condicionada `DiTTransformer2DModel` para desruidar los latentes de imagen codificados. Inicialmente publicado como [`Transformer2DModel`](https://huggingface.co/facebook/DiT-XL-2-256/blob/main/transformer/config.json#L2) en la configuración, pero la discrepancia puede ignorarse. | |
| vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes. | |
| scheduler ([DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. | |
| Pipeline para la generación de imágenes basado en un backbone Transformer en lugar de un UNet. | |
| Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un 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) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/dit/pipeline_dit.py#L101) | |
| **Parámetros:** | |
| class_labels (list[int]) : lista de etiquetas de clases de ImageNet para las imágenes que se van a generar. | |
| guidance_scale (`float`, *opcional*, valor predeterminado 4.0) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. | |
| generator (`torch.Generator`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer que la generación sea determinista. | |
| num_inference_steps (`int`, *opcional*, valor predeterminado 250) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. | |
| output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre `"pil"` (`PIL.Image`), `"np"` (`np.array`) o `"pt"` (`torch.Tensor`). | |
| return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) en lugar de una tupla simple. | |
| **Devuelve:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple` | |
| Si `return_dict` es `True`, se devuelve [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas | |
| La función de llamada para el pipeline de generación. | |
| Ejemplos: | |
| ```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]) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/dit/pipeline_dit.py#L76) | |
| **Parámetros:** | |
| label (`str` o `dict` de `str`) : Cadenas de etiquetas que se mapearán a ids de clase. | |
| **Devuelve:** `list` de `int` | |
| Ids de clase a ser procesados por pipeline. | |
| Mapea las cadenas de etiquetas de ImageNet a los ids de clase correspondientes. | |
| ## ImagePipelineOutput[[diffusers.ImagePipelineOutput]] | |
| #### diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]] | |
| ```python | |
| diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L135) | |
| **Parámetros:** | |
| images (`List[PIL.Image.Image]` o `np.ndarray`) : Lista de imágenes PIL desruidas de longitud `batch_size` o matriz NumPy de forma `(batch_size, height, width, num_channels)`. | |
| Clase de salida para pipelines de imágenes. | |
Xet Storage Details
- Size:
- 7.05 kB
- Xet hash:
- 2898f0e9485ba8007e9a3e04e9b9097b9ad1b6738811947d254456d558b6509e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.