Buckets:
| # AuraFlow | |
| AuraFlow se inspira en [Stable Diffusion 3](../pipelines/stable_diffusion/stable_diffusion_3) y es, con diferencia, el modelo de generación de imágenes a partir de texto más grande que cuenta con una licencia Apache 2.0. Este modelo logra resultados de última generación en el benchmark [GenEval](https://github.com/djghosh13/geneval). | |
| Fue desarrollado por el equipo de Fal y más detalles al respecto se pueden encontrar en [esta publicación de blog](https://blog.fal.ai/auraflow/). | |
| > [!TIP] | |
| > AuraFlow puede resultar bastante costoso de ejecutar en dispositivos de hardware de consumo. Sin embargo, puedes aplicar una serie de optimizaciones para ejecutarlo más rápido y de una manera más eficiente en memoria. Consulta [esta sección](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) para obtener más detalles. | |
| ## Cuantización | |
| La cuantización ayuda a reducir los requisitos de memoria de los modelos muy grandes almacenando los pesos del modelo en un tipo de datos de menor precisión. Sin embargo, la cuantización puede tener un impacto variable en la calidad del vídeo dependiendo del modelo de vídeo. | |
| Consulte el resumen de [Quantization](../../quantization/overview) para obtener más información sobre los backends de cuantización admitidos y la selección de un backend de cuantización que admita su caso de uso. El siguiente ejemplo demuestra cómo cargar un [AuraFlowPipeline](/docs/diffusers/main/es/api/pipelines/aura_flow#diffusers.AuraFlowPipeline) cuantizado para inferencia con bitsandbytes. | |
| ```py | |
| import torch | |
| from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, AuraFlowTransformer2DModel, AuraFlowPipeline | |
| from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel | |
| quant_config = BitsAndBytesConfig(load_in_8bit=True) | |
| text_encoder_8bit = T5EncoderModel.from_pretrained( | |
| "fal/AuraFlow", | |
| subfolder="text_encoder", | |
| quantization_config=quant_config, | |
| dtype=torch.float16, | |
| ) | |
| quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True) | |
| transformer_8bit = AuraFlowTransformer2DModel.from_pretrained( | |
| "fal/AuraFlow", | |
| subfolder="transformer", | |
| quantization_config=quant_config, | |
| dtype=torch.float16, | |
| ) | |
| pipeline = AuraFlowPipeline.from_pretrained( | |
| "fal/AuraFlow", | |
| text_encoder=text_encoder_8bit, | |
| transformer=transformer_8bit, | |
| dtype=torch.float16, | |
| device_map="balanced", | |
| ) | |
| prompt = "a tiny astronaut hatching from an egg on the moon" | |
| image = pipeline(prompt).images[0] | |
| image.save("auraflow.png") | |
| ``` | |
| La carga de [checkpoints GGUF](../../quantization/gguf) también está soportada: | |
| ```py | |
| import torch | |
| from diffusers import ( | |
| AuraFlowPipeline, | |
| GGUFQuantizationConfig, | |
| AuraFlowTransformer2DModel, | |
| ) | |
| transformer = AuraFlowTransformer2DModel.from_single_file( | |
| "https://huggingface.co/city96/AuraFlow-v0.3-gguf/blob/main/aura_flow_0.3-Q2_K.gguf", | |
| quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16), | |
| dtype=torch.bfloat16, | |
| ) | |
| pipeline = AuraFlowPipeline.from_pretrained( | |
| "fal/AuraFlow-v0.3", | |
| transformer=transformer, | |
| dtype=torch.bfloat16, | |
| ) | |
| prompt = "a cute pony in a field of flowers" | |
| image = pipeline(prompt).images[0] | |
| image.save("auraflow.png") | |
| ``` | |
| ## Soporte para `torch.compile()` | |
| AuraFlow se puede compilar con `torch.compile()` para reducir la latencia de inferencia incluso con diferentes resoluciones. Primero, instala PyTorch nightly siguiendo las instrucciones de [aquí](https://pytorch.org/). El fragmento de código siguiente muestra los cambios necesarios para habilitar esto: | |
| ```diff | |
| + torch.fx.experimental._config.use_duck_shape = False | |
| + pipeline.transformer = torch.compile( | |
| pipeline.transformer, fullgraph=True, dynamic=True | |
| ) | |
| ``` | |
| Especificar `use_duck_shape` como `False` indica al compilador si debe usar la misma variable simbólica para representar tamaños de entrada que son iguales. Para más detalles, consulta [este comentario](https://github.com/huggingface/diffusers/pull/11327#discussion_r2047659790). | |
| Esto permite mejoras de velocidad que van desde el 100% (en resoluciones bajas) hasta el 30% (en resolución 1536x1536). | |
| Gracias a [AstraliteHeart](https://github.com/huggingface/diffusers/pull/11297/), quien nos ayudó a reescribir la clase [AuraFlowTransformer2DModel](/docs/diffusers/main/es/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel) para que lo anterior funcione con diferentes resoluciones ([PR](https://github.com/huggingface/diffusers/pull/11297/)). | |
| ## AuraFlowPipeline[[diffusers.AuraFlowPipeline]] | |
| #### diffusers.AuraFlowPipeline[[diffusers.AuraFlowPipeline]] | |
| ```python | |
| diffusers.AuraFlowPipeline(tokenizer: T5Tokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKL, transformer: AuraFlowTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L123) | |
| **Parámetros:** | |
| tokenizer (`T5TokenizerFast`) : Tokenizador de la clase [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). | |
| text_encoder (`T5EncoderModel`) : Codificador de texto congelado. AuraFlow utiliza [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [EleutherAI/pile-t5-xl](https://huggingface.co/EleutherAI/pile-t5-xl). | |
| vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes. | |
| transformer ([AuraFlowTransformer2DModel](/docs/diffusers/main/es/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT y DiT) para desruidar los latentes de imagen codificados. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. | |
| #### __call__[[diffusers.AuraFlowPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, num_inference_steps: int = 50, sigmas: list[float] = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, height: int | None = 1024, width: int | None = 1024, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 256, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents']) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L428) | |
| **Parámetros:** | |
| prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. | |
| negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). | |
| height (`int`, *opcional*, por defecto self.transformer.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados. | |
| width (`int`, *opcional*, por defecto self.transformer.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados. | |
| num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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. | |
| sigmas (`list[float]`, *opcional*) : Sigmas personalizados usados para reemplazar la estrategia de espaciado de pasos de tiempo del programador. Si se pasa `sigmas`, `num_inference_steps` y `timesteps` deben ser `None`. | |
| guidance_scale (`float`, *opcional*, valor predeterminado 5.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. | |
| num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. | |
| generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. | |
| latents (`torch.FloatTensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se usarán como entradas para la generación de imágenes. Se pueden utilizar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. | |
| prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. | |
| prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto. | |
| negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. | |
| negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos. | |
| output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`. | |
| return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` en lugar de una tupla simple. | |
| attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). | |
| callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. | |
| callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. | |
| max_sequence_length (`int` por defecto 256) : Longitud máxima de la secuencia a utilizar con el `prompt`. | |
| **Devuelve:** [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple` | |
| Si `return_dict` es `True`, se devuelve [ImagePipelineOutput](/docs/diffusers/main/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. | |
| Función invocada al llamar a la pipeline para la generación. | |
| Ejemplos: | |
| ```py | |
| >>> import torch | |
| >>> from diffusers import AuraFlowPipeline | |
| >>> pipe = AuraFlowPipeline.from_pretrained("fal/AuraFlow", torch_dtype=torch.float16) | |
| >>> pipe = pipe.to("cuda") | |
| >>> prompt = "A cat holding a sign that says hello world" | |
| >>> image = pipe(prompt).images[0] | |
| >>> image.save("aura_flow.png") | |
| ``` | |
| #### encode_prompt[[diffusers.AuraFlowPipeline.encode_prompt]] | |
| ```python | |
| encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] = None, do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 256, lora_scale: float | None = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L232) | |
| **Parámetros:** | |
| prompt (`str` o `list[str]`, *opcional*) : prompt a codificar | |
| negative_prompt (`str` o `list[str]`, *opcional*) : El prompt que no debe guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). | |
| do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no | |
| num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de imágenes que deben generarse por indicación | |
| device : (`torch.device`, *opcional*): dispositivo de torch en el que colocar las incrustaciones resultantes | |
| prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. | |
| prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto. | |
| negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados. | |
| negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos. | |
| max_sequence_length (`int`, por defecto 256) : Longitud máxima de la secuencia a utilizar para el prompt. | |
| lora_scale (`float`, *opcional*) : Una escala lora que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA. | |
| Codifica el prompt en estados ocultos del codificador de texto. | |
Xet Storage Details
- Size:
- 15.5 kB
- Xet hash:
- 5a609c850d0bbd7538b48869532ee6610e13c83e95570fee55d320fcb4c925db
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.