Buckets:
| # AuraFlow | |
| AuraFlow terinspirasi oleh [Stable Diffusion 3](../pipelines/stable_diffusion/stable_diffusion_3) dan merupakan model generasi teks-ke-gambar terbesar sejauh ini yang dilengkapi dengan lisensi Apache 2.0. Model ini mencapai hasil state-of-the-art pada benchmark [GenEval](https://github.com/djghosh13/geneval). | |
| Ini dikembangkan oleh tim Fal dan detail lebih lanjut dapat ditemukan di [artikel blog ini](https://blog.fal.ai/auraflow/). | |
| > [!TIP] | |
| > AuraFlow dapat menjadi cukup mahal untuk dijalankan pada perangkat hardware konsumen. Namun, Anda dapat melakukan serangkaian optimasi untuk menjalankannya lebih cepat dan dengan cara yang lebih hemat memori. Lihat [bagian ini](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) untuk detail lebih lanjut. | |
| ## Kuantisasi | |
| Quantization membantu mengurangi kebutuhan memori untuk model yang sangat besar dengan menyimpan bobot model dalam tipe data presisi yang lebih rendah. Namun, quantization dapat memiliki dampak yang bervariasi terhadap kualitas video tergantung pada model video yang digunakan. | |
| Lihat ringkasan [Kuantisasi](../../quantization/overview) untuk mempelajari lebih lanjut tentang backend kuantisasi yang didukung dan memilih backend kuantisasi yang mendukung kasus penggunaan Anda. Contoh di bawah ini menunjukkan cara memuat [AuraFlowPipeline](/docs/diffusers/main/id/api/pipelines/aura_flow#diffusers.AuraFlowPipeline) yang dikuantisasi untuk inferensi dengan 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") | |
| ``` | |
| Memuat [checkpoint GGUF](../../quantization/gguf) juga didukung: | |
| ```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") | |
| ``` | |
| ## Dukungan untuk `torch.compile()` | |
| AuraFlow dapat dikompilasi dengan `torch.compile()` untuk mempercepat latensi inferensi bahkan untuk resolusi yang berbeda. Pertama, instal PyTorch nightly mengikuti instruksi dari [sini](https://pytorch.org/). Cuplikan kode di bawah ini menunjukkan perubahan yang diperlukan untuk mengaktifkan ini: | |
| ```diff | |
| + torch.fx.experimental._config.use_duck_shape = False | |
| + pipeline.transformer = torch.compile( | |
| pipeline.transformer, fullgraph=True, dynamic=True | |
| ) | |
| ``` | |
| Menetapkan `use_duck_shape` menjadi `False` memberi instruksi kepada compiler apakah harus menggunakan variabel simbolik yang sama untuk merepresentasikan ukuran input yang sama. Untuk detail lebih lanjut, lihat [komentar ini](https://github.com/huggingface/diffusers/pull/11327#discussion_r2047659790). | |
| Hal ini memungkinkan peningkatan kecepatan dari 100% (pada resolusi rendah) hingga 30% (pada resolusi 1536x1536). | |
| Terima kasih kepada [AstraliteHeart](https://github.com/huggingface/diffusers/pull/11297/) yang telah membantu kami menulis ulang kelas [AuraFlowTransformer2DModel](/docs/diffusers/main/id/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel) sehingga hal di atas dapat berfungsi untuk resolusi yang berbeda ([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) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L123) | |
| **Parameter:** | |
| tokenizer (`T5TokenizerFast`) : Tokenizer dari kelas [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). | |
| text_encoder (`T5EncoderModel`) : Text-encoder yang dibekukan. AuraFlow menggunakan [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), khususnya varian [EleutherAI/pile-t5-xl](https://huggingface.co/EleutherAI/pile-t5-xl). | |
| vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten. | |
| transformer ([AuraFlowTransformer2DModel](/docs/diffusers/main/id/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT dan DiT) untuk mendenoise latens gambar yang telah dikodekan. | |
| scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan. | |
| #### __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']) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L428) | |
| **Parameter:** | |
| prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya. | |
| negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). | |
| height (`int`, *opsional*, defaultnya self.transformer.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik. | |
| width (`int`, *opsional*, defaultnya self.transformer.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik. | |
| num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat. | |
| sigmas (`list[float]`, *opsional*) : Sigma kustom yang digunakan untuk menimpa strategi penjarakan langkah waktu (timestep) dari penjadwal. Jika `sigmas` diberikan, `num_inference_steps` dan `timesteps` harus `None`. | |
| guidance_scale (`float`, *opsional*, default 5.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah. | |
| num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt. | |
| generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik. | |
| latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan. | |
| prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. | |
| prompt_attention_mask (`torch.Tensor`, *opsional*) : Mask perhatian yang telah dibuat sebelumnya untuk embedding teks. | |
| negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`. | |
| negative_prompt_attention_mask (`torch.Tensor`, *opsional*) : Mask perhatian yang telah dibuat sebelumnya untuk embedding teks negatif. | |
| output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`. | |
| return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput` alih-alih tuple biasa. | |
| attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). | |
| callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`. | |
| callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda. | |
| max_sequence_length (`int` defaultnya 256) : Panjang maksimum urutan yang digunakan dengan `prompt`. | |
| **Mengembalikan:** [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) atau `tuple` | |
| Jika `return_dict` adalah `True`, [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan. | |
| Fungsi yang dipanggil saat memanggil pipeline untuk generasi. | |
| Contoh: | |
| ```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) | |
| ``` | |
| [Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L232) | |
| **Parameter:** | |
| prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod | |
| negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt yang tidak digunakan untuk memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). | |
| do_classifier_free_guidance (`bool`, *opsional*, defaultnya `True`) : apakah akan menggunakan classifier free guidance atau tidak | |
| num_images_per_prompt (`int`, *opsional*, default 1) : jumlah gambar yang harus dihasilkan per prompt | |
| device : (`torch.device`, *opsional*): perangkat torch untuk menempatkan embedding yang dihasilkan | |
| prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`. | |
| prompt_attention_mask (`torch.Tensor`, *opsional*) : Mask perhatian yang telah dibuat sebelumnya untuk embedding teks. | |
| negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. | |
| negative_prompt_attention_mask (`torch.Tensor`, *opsional*) : Mask perhatian yang telah dibuat sebelumnya untuk embedding teks negatif. | |
| max_sequence_length (`int`, defaultnya 256) : Panjang maksimum urutan yang digunakan untuk prompt. | |
| lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat. | |
| Mengkodekan prompt menjadi hidden states dari text encoder. | |
Xet Storage Details
- Size:
- 15.3 kB
- Xet hash:
- 2f00818bb647cad369fafdf66ce42690d488d61f47301d70d35cbe254a8d6f70
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.