hf-doc-build/doc / diffusers /main /id /api /pipelines /sana.md

|

raw

33 kB

Berlisensi di bawah Apache License, Versi 2.0 ("Lisensi");

Anda mungkin tidak dapat menggunakan file ini kecuali sesuai dengan Lisensi.

Anda dapat memperoleh salinan Lisensi di

http://www.apache.org/licenses/LICENSE-2.0

Kecuali diwajibkan oleh hukum yang berlaku atau disepakati secara tertulis, perangkat lunak

distribusikan di bawah Lisensi berdasarkan basis "SEBAGAIMANA ADANYA",

TANPA JAMINAN ATAU SYARAT DALAM BENTUK APAPUN, baik yang dinyatakan maupun yang tersirat.

Lihat Lisensi untuk bahasa tertentu yang mengatur izin dan

batasan di bawah Lisensi. -->

SanaPipeline

SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers dari NVIDIA dan MIT HAN Lab, oleh Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han.

Abstrak dari makalah tersebut adalah:

Kami memperkenalkan Sana, sebuah kerangka kerja teks-ke-gambar yang dapat menghasilkan gambar hingga resolusi 4096×4096 secara efisien. Sana dapat mensintesis gambar beresolusi tinggi dan berkualitas tinggi dengan keselarasan teks-gambar yang kuat pada kecepatan yang sangat cepat, dan dapat di-deploy pada GPU laptop. Desain intinya meliputi: (1) Autoencoder kompresi dalam: berbeda dengan AE tradisional yang hanya mengompresi gambar 8×, kami melatih AE yang dapat mengompresi gambar 32×, secara efektif mengurangi jumlah token laten. (2) Linear DiT: kami mengganti semua vanilla attention di DiT dengan linear attention, yang lebih efisien pada resolusi tinggi tanpa mengorbankan kualitas. (3) Text encoder hanya-decoder: kami mengganti T5 dengan LLM kecil modern hanya-decoder sebagai text encoder dan merancang instruksi manusia yang kompleks dengan in-context learning untuk meningkatkan keselarasan gambar-teks. (4) Pelatihan dan sampling yang efisien: kami mengusulkan Flow-DPM-Solver untuk mengurangi langkah sampling, dengan pelabelan dan seleksi caption yang efisien untuk mempercepat konvergensi. Akibatnya, Sana-0.6B sangat kompetitif dengan model difusi raksasa modern (misalnya Flux-12B), berukuran 20 kali lebih kecil dan 100+ kali lebih cepat dalam throughput yang diukur. Selain itu, Sana-0.6B dapat di-deploy pada GPU laptop 16GB, membutuhkan waktu kurang dari 1 detik untuk menghasilkan gambar beresolusi 1024×1024. Sana memungkinkan pembuatan konten dengan biaya rendah. Kode dan model akan dirilis secara publik.

Pastikan untuk melihat panduan Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian reuse components across pipelines untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline.

Pipeline ini disumbangkan oleh lawrence-cj dan chenjy2003. Basis kode asli dapat ditemukan di sini. Bobot asli dapat ditemukan di bawah hf.co/Efficient-Large-Model.

Model yang tersedia:

Model	dtype yang direkomendasikan
`Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers`	`torch.bfloat16`
`Efficient-Large-Model/Sana_1600M_1024px_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_1600M_1024px_MultiLing_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_1600M_512px_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_1600M_512px_MultiLing_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_600M_1024px_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_600M_512px_diffusers`	`torch.float16`

Lihat koleksi ini untuk informasi lebih lanjut.

Catatan: dtype yang direkomendasikan tersebut adalah untuk bobot transformer. Bobot text encoder dan VAE harus tetap dalam torch.bfloat16 atau torch.float32 agar model dapat berfungsi dengan benar. Silakan lihat contoh inferensi di bawah untuk melihat cara memuat model dengan dtype yang direkomendasikan.

Pastikan untuk meneruskan argumen variant untuk checkpoint yang diunduh guna menggunakan ruang disk yang lebih rendah. Atur menjadi "fp16" untuk model dengan dtype yang direkomendasikan sebagai torch.float16, dan "bf16" untuk model dengan dtype yang direkomendasikan sebagai torch.bfloat16. Secara default, bobot torch.float32 yang diunduh, yang menggunakan dua kali lipat penyimpanan disk. Selain itu, bobot torch.float32 dapat diturunkan secara langsung dengan menentukan argumen dtype. Baca tentang hal ini di dokumentasi.

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 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 SanaPipeline yang dikuantisasi untuk inferensi dengan bitsandbytes.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, SanaTransformer2DModel, SanaPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, AutoModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = AutoModel.from_pretrained(
    "Efficient-Large-Model/Sana_1600M_1024px_diffusers",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = SanaTransformer2DModel.from_pretrained(
    "Efficient-Large-Model/Sana_1600M_1024px_diffusers",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = SanaPipeline.from_pretrained(
    "Efficient-Large-Model/Sana_1600M_1024px_diffusers",
    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("sana.png")

SanaPipeline[[diffusers.SanaPipeline]]

diffusers.SanaPipeline[[diffusers.SanaPipeline]]

diffusers.SanaPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: DPMSolverMultistepScheduler)

Sumber

Pipeline untuk generasi teks-ke-gambar menggunakan Sana.

call[[diffusers.SanaPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 20, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 4.5, num_images_per_prompt: int | None = 1, height: int = 1024, width: int = 1024, eta: float = 0.0, 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, output_type: str | None = 'pil', return_dict: bool = True, clean_caption: bool = False, use_resolution_binning: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 300, complex_human_instruction: list[str] = ["Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.', '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', 'Here are examples of how to transform or refine prompts:', '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.', '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.', 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', 'User Prompt: '])

Sumber

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).

num_inference_steps (int, opsional, defaultnya 20) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

timesteps (list[int], opsional) : Timesteps kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen timesteps di metode set_timesteps mereka. Jika tidak didefinisikan, perilaku default saat num_inference_steps diteruskan akan digunakan. Harus dalam urutan menurun.

sigmas (list[float], opsional) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen sigmas di metode set_timesteps mereka. Jika tidak didefinisikan, perilaku default saat num_inference_steps diteruskan akan digunakan.

guidance_scale (float, opsional, default 4.5) : Skala panduan seperti yang didefinisikan dalam Classifier-Free Diffusion Guidance. guidance_scale didefinisikan sebagai w dari persamaan 2. pada Imagen Paper. 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.

height (int, opsional, defaultnya self.unet.config.sample_size) : Tinggi gambar yang dihasilkan dalam piksel.

width (int, opsional, defaultnya self.unet.config.sample_size) : Lebar gambar yang dihasilkan dalam piksel.

eta (float, opsional, default 0.0) : Bersesuaian dengan parameter eta (η) dalam paper DDIM: https://huggingface.co/papers/2010.02502. Hanya berlaku untuk schedulers.DDIMScheduler, akan diabaikan untuk yang lain.

generator (torch.Generator atau list[torch.Generator], opsional) : Satu atau daftar generator torch untuk membuat proses generasi menjadi deterministik.

latents (torch.Tensor, 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.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. Untuk PixArt-Sigma, prompt negatif ini harus "". 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: PIL.Image.Image atau np.array.

return_dict (bool, opsional, defaultnya True) : Apakah akan mengembalikan ~pipelines.stable_diffusion.IFPipelineOutput alih-alih tuple biasa.

attention_kwargs : Kamus kwargs yang jika ditentukan akan diteruskan ke AttentionProcessor yang didefinisikan di bawah self.processor dalam diffusers.models.attention_processor.

clean_caption (bool, opsional, defaultnya True) : Apakah caption akan dibersihkan sebelum membuat embeddings. Memerlukan beautifulsoup4 dan ftfy terpasang. Jika dependensi tidak terpasang, embeddings akan dibuat dari prompt mentah.

use_resolution_binning (bool defaultnya True) : Jika diset ke True, tinggi dan lebar yang diminta pertama kali dipetakan ke resolusi terdekat menggunakan ASPECT_RATIO_1024_BIN. Setelah latents yang dihasilkan didekode menjadi gambar, ukurannya dikembalikan ke resolusi yang diminta. Berguna untuk menghasilkan gambar yang tidak persegi.

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 300) : Panjang maksimum urutan yang digunakan dengan prompt.

complex_human_instruction (list[str], opsional) : Instruksi untuk perhatian manusia yang kompleks: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55.

Mengembalikan: SanaPipelineOutput atau tuple

Jika return_dict adalah True, SanaPipelineOutput 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:

>>> import torch
>>> from diffusers import SanaPipeline

>>> pipe = SanaPipeline.from_pretrained(
...     "Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers", torch_dtype=torch.float32
... )
>>> pipe.to("cuda")
>>> pipe.text_encoder.to(torch.bfloat16)
>>> pipe.transformer = pipe.transformer.to(torch.bfloat16)

>>> image = pipe(prompt='a cyberpunk cat with a neon sign that says "Sana"')[0]
>>> image[0].save("output.png")

encode_prompt[[diffusers.SanaPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', 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, clean_caption: bool = False, max_sequence_length: int = 300, complex_human_instruction: list[str] | None = None, lora_scale: float | None = None)

Sumber

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 panduan (yaitu, diabaikan jika guidance_scale kurang dari 1). Untuk PixArt-Alpha, ini harus berupa "".

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.

negative_prompt_embeds (torch.Tensor, opsional) : Embedding teks negatif yang telah dibuat sebelumnya. Untuk Sana, ini seharusnya berupa embedding dari string "".

clean_caption (bool, defaultnya False) : Jika True, fungsi akan memproses pra dan membersihkan caption yang diberikan sebelum pengkodean.

max_sequence_length (int, defaultnya 300) : Panjang maksimum urutan yang digunakan untuk prompt.

complex_human_instruction (list[str], defaultnya complex_human_instruction) : Jika complex_human_instruction tidak kosong, fungsi akan menggunakan instruksi Human yang kompleks untuk prompt.

Mengkodekan prompt menjadi hidden states dari text encoder.

SanaPAGPipeline[[diffusers.SanaPAGPipeline]]

diffusers.SanaPAGPipeline[[diffusers.SanaPAGPipeline]]

diffusers.SanaPAGPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, pag_applied_layers: str | list[str] = 'transformer_blocks.0')

Sumber

Pipeline untuk generasi teks-ke-gambar menggunakan Sana. Pipeline ini mendukung penggunaan Perturbed Attention Guidance (PAG).

call[[diffusers.SanaPAGPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 20, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 4.5, num_images_per_prompt: int | None = 1, height: int = 1024, width: int = 1024, eta: float = 0.0, 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, output_type: str | None = 'pil', return_dict: bool = True, clean_caption: bool = False, use_resolution_binning: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 300, complex_human_instruction: list[str] = ["Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.', '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', 'Here are examples of how to transform or refine prompts:', '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.', '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.', 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', 'User Prompt: '], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0)