diffusers/main/id/api/pipelines/kandinsky6.md

Kandinsky 6

Kandinsky 6 adalah keluarga model generasi video dari Kandinsky Lab. Model utama menghasilkan video dan audio yang tersinkronisasi dari teks atau gambar referensi dengan satu transformer difusi multimodal: latens video dan audio didenoise bersama melalui blok-blok yang terfusi, yang melakukan cross-attention di antara kedua modalitas, masing-masing dikondisikan pada cabang teks Qwen2.5-VL-nya sendiri dan embedding CLIP yang dipool. Model super-resolusi yang terpisah memperbesar video yang dihasilkan secara per-tile di ruang latens dari K-VAE 3D kausal.

Lihat organisasi Kandinsky Lab di Hub untuk kumpulan lengkap checkpoint resmi, termasuk varian flow-matching dan distilled dari model base dan super-resolution.

Checkpoint yang telah di-distil dikirimkan bersama PiflowScheduler beberapa langkah dan harus dijalankan dengan guidance_scale=1.0.

Model yang tersedia

Model	Pipeline	Catatan
kandinskylab/Kandinsky-6.0-Pro-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 langkah
kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Distil, guidance_scale=1.0, 10 langkah
kandinskylab/Kandinsky-6.0-Lite-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 langkah
kandinskylab/Kandinsky-6.0-Lite-distill-5s-Diffusers	Kandinsky6TI2VAPipeline	Distil, guidance_scale=1.0, 10 langkah
kandinskylab/Kandinsky-6.0-Pro-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 langkah
kandinskylab/Kandinsky-6.0-Lite-pretrain-5s-Diffusers	Kandinsky6TI2VAPipeline	Flow matching, guidance_scale=5.0, 50 langkah
kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers	Kandinsky6SRPipeline	Super-resolusi pencocokan aliran
kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers	Kandinsky6SRPipeline	Super-resolusi terdistil, 2 langkah

Teks/gambar-ke-video-dan-audio

import torch
from diffusers import Kandinsky6TI2VAPipeline
from diffusers.utils import encode_video

pipe = Kandinsky6TI2VAPipeline.from_pretrained(
    "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

output = pipe(
    prompt="A cat and a dog baking a cake together in a kitchen.",
    height=480,
    width=864,
    num_frames=121,
    num_inference_steps=10,
    guidance_scale=1.0,
)
encode_video(
    output.frames[0],
    fps=24,
    output_path="output.mp4",
    audio=output.audio[0][None],
    audio_sample_rate=pipe.audio_sample_rate,
)

Lewati image= untuk mengondisikan bingkai pertama pada gambar referensi, sample_audio=False untuk hanya menghasilkan video, dan expand_prompts=True agar pengkode teks Qwen2.5-VL menulis ulang prompt pendek menjadi prompt yang lebih detail terlebih dahulu.

Super-resolusi video

Kandinsky6SRPipeline mengambil frame yang dihasilkan oleh Kandinsky6TI2VAPipeline dan memperbesarnya sebesar 2, 4, atau 2.25 (pre-upscale bilinear 1.125x diikuti jalur 2x). Video dipecah menjadi tile yang saling tumpang tindih, setiap tile disempurnakan pada salah satu ukuran tile yang digunakan saat pelatihan transformer SR, dan tile tersebut digabungkan kembali menggunakan jendela Hann.

# required: lets inductor pick flex-attention tiles that fit the SR block mask
torch._inductor.config.max_autotune = True  

sr_pipe = Kandinsky6SRPipeline.from_pretrained(
    "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", torch_dtype=torch.bfloat16
)
# The SR transformer always runs NABLA sparse attention on the `flex` backend. Compile it, otherwise flex falls
# back to an eager implementation that needs far more memory at video resolutions.
sr_pipe.enable_model_cpu_offload()
sr_pipe.transformer.set_attention_backend("flex")
sr_pipe.transformer.compile_repeated_blocks(fullgraph=True)

upscaled = sr_pipe(video=output.frames[0], resolution_scale=2.25, num_inference_steps=2).frames[0]

Optimasi memori

Lihat panduan Reduce memory usage untuk kumpulan teknik umum. Baik Kandinsky6TI2VAPipeline maupun Kandinsky6SRPipeline mendukung model offloading (digunakan di atas) dan, untuk footprint yang lebih kecil dengan mengorbankan kecepatan, sequential CPU offloading:

pipe.enable_sequential_cpu_offload()

Video VAE dari Kandinsky6TI2VAPipeline juga mendukung tiled decoding untuk resolusi tinggi atau video panjang:

pipe.vae.enable_tiling()

Catatan

• height dan width harus dapat dibagi habis oleh rasio kompresi spasial VAE video dikalikan ukuran patch transformer — 16 dengan konfigurasi Kandinsky6TI2VAPipeline bawaan (AutoencoderKLHunyuanVideo dengan rasio kompresi 8, patch_size=(1, 2, 2)). 480x864, yang digunakan dalam contoh di atas, memenuhi syarat ini.
• Input video dari Kandinsky6SRPipeline harus memiliki 1 + k * vae_scale_factor_temporal frame untuk beberapa bilangan bulat k (rasio kompresi temporal 4 dengan konfigurasi K-VAE default, sehingga 121 frame berfungsi tetapi 120 tidak) — pangkas atau tambahkan padding pada video yang belum memenuhi syarat ini sebelum melakukan upscaling.
• expand_prompts=True menggunakan ulang pengkode teks Qwen2.5-VL yang sudah dimuat untuk satu langkah generasi tambahan sebelum denoising, sehingga menambah latensi tetapi tidak menambah bobot model.
• Compile blok transformer yang berulang untuk inferensi berulang yang lebih cepat:

  pipe.transformer.compile_repeated_blocks(fullgraph=True)
  

Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]]

diffusers.Kandinsky6TI2VAPipeline[[diffusers.Kandinsky6TI2VAPipeline]]

diffusers.Kandinsky6TI2VAPipeline(transformer: Kandinsky6Transformer3DModel, vae: AutoencoderKLHunyuanVideo, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2_5_VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduler, audio_vae: diffusers.models.autoencoders.autoencoder_mmaudio.MMAudioVAE | None = None, vocoder: diffusers.models.autoencoders.mmaudio_vocoder.MMAudioVocoder | None = None)

Sumber

Parameter:

transformer (Kandinsky6Transformer3DModel) : Transformer multimodal yang melakukan denoising pada latens video dan audio.

vae (AutoencoderKLHunyuanVideo) : VAE video yang digunakan untuk mengkodekan gambar referensi dan mendekodekan video yang dihasilkan.

text_encoder (Qwen2_5_VLForConditionalGeneration) : Model Qwen2.5-VL yang menyediakan embedding teks tingkat token dan, secara opsional, perluasan prompt.

tokenizer (Qwen2_5_VLProcessor) : Pemroses untuk text_encoder.

text_encoder_2 (CLIPTextModel) : encoder teks CLIP yang menyediakan embedding teks yang dipool.

tokenizer_2 (CLIPTokenizer) : Tokenizer untuk text_encoder_2.

scheduler (FlowMatchEulerDiscreteScheduler atau PiflowScheduler) : Scheduler yang digunakan bersama transformer untuk menghilangkan noise pada latents. Checkpoint yang telah didistilkan dilengkapi dengan PiflowScheduler dan harus dijalankan dengan guidance_scale=1.0.

audio_vae (MMAudioVAE, opsional) : Audio VAE yang digunakan untuk mendekode latens audio yang dihasilkan menjadi spektrogram mel. Hanya diperlukan ketika sample_audio=True.

vocoder (MMAudioVocoder, opsional) : Vocoder yang digunakan untuk mengubah mel spectrogram yang didekode oleh audio_vae menjadi waveform. Hanya diperlukan ketika sample_audio=True.

Pipeline untuk generasi teks/gambar-ke-video-dan-audio dengan Kandinsky 6.

Latent video dan audio didenois bersama oleh satu transformer multimodal, dikondisikan oleh token teks Qwen2.5-VL dan embedding CLIP yang dipool. Gambar referensi opsional mengondisikan frame pertama.

Model ini mewarisi dari DiffusionPipeline. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).

call[[diffusers.Kandinsky6TI2VAPipeline.call]]

__call__(prompt: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, frame_rate: float = 24.0, num_inference_steps: int = 50, timesteps: list[int] | None = None, sigmas: list[float] | None = None, guidance_scale: float = 5.0, num_videos_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, sample_audio: bool = True, expand_prompts: bool = False, max_sequence_length: int = 1024, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: collections.abc.Callable[[int, int, dict], None] | None = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])

Sumber

Parameter:

prompt (str atau list[str], opsional) : Prompt atau prompt-prompt untuk mengarahkan generasi. Wajib diisi kecuali prompt_embeds diberikan.

image (PipelineImageInput, optional) : Reference image(s) conditioning the first frame (image-to-video-and-audio).

negative_prompt (str atau list[str], opsional) : Prompt atau prompt-prompt yang tidak akan memandu generasi. Bawaan adalah prompt negatif Kandinsky 6.

height (int, defaultnya 512) : Tinggi video yang dihasilkan dalam piksel.

width (int, defaultnya 768) : Lebar video yang dihasilkan dalam piksel.

num_frames (int, defaultnya 121) : Jumlah frame yang dihasilkan.

frame_rate (float, defaultnya 24.0) : Laju bingkai video yang dihasilkan; mengatur panjang audio yang disinkronkan.

num_inference_steps (int, defaultnya 50) : Jumlah langkah denoising. Gunakan 16 dengan checkpoint yang telah didistilasi.

timesteps (list[int], opsional) : Timesteps kustom untuk scheduler yang mendukungnya.

sigmas (list[float], opsional) : Sigma kustom untuk scheduler yang mendukungnya.

guidance_scale (float, defaultnya 5.0) : Skala panduan bebas klasifikasi. Harus 1.0 dengan PiflowScheduler.

num_videos_per_prompt (int, defaultnya 1) : Jumlah video yang akan dihasilkan per prompt.

generator (torch.Generator atau list[torch.Generator], opsional) : Generator yang digunakan untuk noise awal dan encoding gambar referensi.

latents (torch.Tensor, opsional) : Laten video yang telah dibuat sebelumnya dengan bentuk (batch_size, channels, num_latent_frames, latent_height, latent_width).

audio_latents (torch.Tensor, opsional) : Laten audio yang telah dibuat sebelumnya dengan bentuk (batch_size, channels, audio_length).

prompt_embeds (torch.Tensor, opsional) : Embedding teks Qwen2.5-VL yang telah dibuat sebelumnya.

pooled_prompt_embeds (torch.Tensor, opsional) : Embedding teks CLIP yang sudah digenerate sebelumnya.

negative_prompt_embeds (torch.Tensor, opsional) : Embedding teks negatif Qwen2.5-VL yang telah dibuat sebelumnya.

negative_pooled_prompt_embeds (torch.Tensor, opsional) : Embedding teks CLIP pooled negatif yang telah dibuat sebelumnya.

sample_audio (bool, defaultnya True) : Apakah akan menghasilkan audio yang tersinkronisasi. Memerlukan pipeline yang memiliki audio_vae dan vocoder.

expand_prompts (bool, defaultnya False) : Apakah prompt akan ditulis ulang dengan expand_prompts() sebelum di-encode.

max_sequence_length (int, defaultnya 1024) : Jumlah maksimum token prompt setelah template chat.

output_type (str, defaultnya "pil") : Format output dari video yang dihasilkan: "pil", "np", "pt" atau "latent".

return_dict (bool, defaultnya True) : Apakah akan mengembalikan Kandinsky6TI2VAPipelineOutput alih-alih tuple biasa.

callback_on_step_end (Callable, opsional) : Fungsi yang dipanggil di akhir setiap langkah denoising dengan callback_on_step_end(self, step, timestep, callback_kwargs). Fungsi ini dapat mengembalikan dict yang menimpa tensor yang terdaftar.

callback_on_step_end_tensor_inputs (list[str], defaultnya ["latents"]) : Input Tensor yang diteruskan ke callback_on_step_end; subset dari _callback_tensor_inputs.

Mengembalikan: Kandinsky6TI2VAPipelineOutput atau tuple

Video dan audio yang dihasilkan; tuple (frames, audio) ketika return_dict=False.

Fungsi panggilan untuk pipeline pada generasi.

Contoh:

>>> import torch
>>> from diffusers import Kandinsky6TI2VAPipeline
>>> from diffusers.utils import encode_video

>>> pipe = Kandinsky6TI2VAPipeline.from_pretrained(
...     "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16
... )
>>> pipe.enable_model_cpu_offload()

>>> output = pipe(
...     prompt="A cat and a dog baking a cake together in a kitchen.",
...     height=480,
...     width=864,
...     num_frames=121,
...     num_inference_steps=16,
...     guidance_scale=1.0,
... )
>>> encode_video(
...     output.frames[0],
...     fps=24,
...     output_path="output.mp4",
...     audio=output.audio[0][None],
...     audio_sample_rate=pipe.audio_sample_rate,
... )

encode_image[[diffusers.Kandinsky6TI2VAPipeline.encode_image]]

encode_image(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], height: int, width: int, device: device, dtype: dtype, num_videos_per_prompt: int = 1, generator: typing.Optional[torch.Generator] = None)

Sumber

Mengode gambar referensi menjadi latens bingkai pertama dengan bentuk (batch_size, latent_height, latent_width, latent_channels), yang diskalakan oleh scaling_factor VAE. Gambar PIL di-resize dan di-crop di tengah menjadi height x width; tensor dan array harus sudah memiliki ukuran tersebut. Latens diulang sebanyak num_videos_per_prompt kali sepanjang dimensi batch.

encode_prompt[[diffusers.Kandinsky6TI2VAPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)

Sumber

Parameter:

prompt (str atau list[str]) : Prompt yang akan dienkod.

negative_prompt (str atau list[str], opsional) : Prompt yang tidak memandu generasi. Diabaikan ketika do_classifier_free_guidance adalah False.

do_classifier_free_guidance (bool, defaultnya True) : Apakah prompt negatif juga akan dienkripsi.

num_videos_per_prompt (int, defaultnya 1) : Jumlah video yang dihasilkan per prompt; embedding diulang sesuai dengan jumlah tersebut.

prompt_embeds (torch.Tensor, opsional) : Embedding teks Qwen2.5-VL yang telah dibuat sebelumnya. Melewati pengkodean prompt.

pooled_prompt_embeds (torch.Tensor, opsional) : Embedding teks CLIP yang sudah digenerate sebelumnya. Harus diberikan bersama dengan prompt_embeds.

prompt_attention_mask (torch.Tensor, opsional) : Mask padding Boolean untuk prompt_embeds.

negative_prompt_embeds (torch.Tensor, opsional) : Embedding teks negatif Qwen2.5-VL yang telah dibuat sebelumnya.

negative_pooled_prompt_embeds (torch.Tensor, opsional) : Embedding teks CLIP pooled negatif yang telah dibuat sebelumnya.

negative_prompt_attention_mask (torch.Tensor, opsional) : Mask padding Boolean untuk negative_prompt_embeds.

max_sequence_length (int, defaultnya 1024) : Jumlah maksimum token prompt setelah template chat.

device (torch.device, opsional) : Perangkat untuk menjalankan text encoder.

dtype (torch.dtype, opsional) : Dtype dari embedding yang dikembalikan.

Mengkodekan prompt menjadi hidden states dari text encoder.

expand_prompts[[diffusers.Kandinsky6TI2VAPipeline.expand_prompts]]

expand_prompts(prompt: str | list[str], tokenizer, text_encoder, device: device, image: PIL.Image.Image | list[PIL.Image.Image] | None = None, max_sequence_length: int = 1024, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None)

Sumber

Parameter:

prompt (str atau list[str]) : Prompt atau prompt yang akan diperluas.

tokenizer : Prosesor Qwen2.5-VL, misalnya pipe.tokenizer.

text_encoder : Model Qwen2.5-VL, misalnya pipe.text_encoder.

device (torch.device) : Perangkat untuk menjalankan text encoder.

image (PIL.Image.Image atau list[PIL.Image.Image], opsional) : Gambar referensi untuk panggilan image-to-video.

max_sequence_length (int, defaultnya 1024) : Jumlah maksimum token yang dihasilkan per prompt.

generator (torch.Generator atau list[torch.Generator], opsional) : Menetapkan benih (seed) untuk ekspansi yang disampelkan; daftar harus sesuai dengan panjang prompt, satu generator per item. generate mengambil dari RNG global, sehingga RNG global diberi benih dari benih generator ini; pemanggilan randn_tensor selanjutnya tetap menggunakan generator secara langsung.

Mengembalikan: str atau list[str]

Prompt yang diperluas.

Menulis ulang prompt pendek menjadi prompt video+audio yang detail dengan encoder teks Qwen2.5-VL, dengan mengaitkannya pada gambar referensi jika diberikan. Sebuah staticmethod sehingga dapat digunakan secara mandiri, sebelum menjalankan pipeline.

prepare_audio_latents[[diffusers.Kandinsky6TI2VAPipeline.prepare_audio_latents]]

prepare_audio_latents(batch_size: int, num_channels_latents: int, audio_length: int, dtype: dtype, device: device, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType], audio_latents: typing.Optional[torch.Tensor] = None)

Sumber

Mengembalikan latens audio dalam tata letak (batch_size, audio_length, channels) dari transformer. Tensor audio_latents yang disediakan pengguna diharapkan dalam tata letak (batch_size, channels, audio_length).

prepare_latents[[diffusers.Kandinsky6TI2VAPipeline.prepare_latents]]

prepare_latents(batch_size: int, num_channels_latents: int, height: int, width: int, num_frames: int, dtype: dtype, device: device, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType], latents: typing.Optional[torch.Tensor] = None)

Sumber

Mengembalikan latens video dalam tata letak (batch_size, num_frames, height, width, channels) dari transformer. Tensor latents yang disediakan pengguna diharapkan dalam tata letak (batch_size, channels, num_frames, height, width).

Kandinsky6SRPipeline[[diffusers.Kandinsky6SRPipeline]]

diffusers.Kandinsky6SRPipeline[[diffusers.Kandinsky6SRPipeline]]

diffusers.Kandinsky6SRPipeline(transformer: Kandinsky6SRTransformer3DModel, vae: Kandinsky6SRVAE, scheduler: diffusers.schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteScheduler | diffusers.schedulers.scheduling_piflow.PiflowScheduler, latent_upscaler: diffusers.models.latent_upscaler.latent_upscaler_kandinsky6_sr.Kandinsky6SRLatentUpscalerBank | None = None)

Sumber

Parameter:

transformer (Kandinsky6SRTransformer3DModel) : Transformer yang menyempurnakan ubin laten.

vae (Kandinsky6SRVAE) : K-VAE video kausal yang digunakan untuk mengkodekan video input dan mendekodekan ubin yang telah disempurnakan.

scheduler (FlowMatchEulerDiscreteScheduler atau PiflowScheduler) : Scheduler yang digunakan bersama transformer untuk menghilangkan noise pada tile. Checkpoint yang telah didistilkan dilengkapi dengan PiflowScheduler.

latent_upscaler (Kandinsky6SRLatentUpscalerBank, opsional) : Upscaler laten untuk skala yang didukung.

Pipeline untuk super-resolusi video dengan Kandinsky 6.

Video dipecah menjadi ubin spasial yang saling tumpang tindih, setiap ubin disempurnakan oleh transformer SR pada salah satu ukuran ubin yang digunakan saat pelatihan model (transformer.config.tile_sizes), dan ubin yang telah disempurnakan tersebut dicampur kembali menggunakan jendela Hann. Ketika pipeline memiliki latent_upscaler, ubin dipotong dari latens K-VAE dari seluruh video dan di-upscale di ruang latens; jika tidak, ubin piksel di-upscale secara bilinear dan kemudian di-encode.

Model ini mewarisi dari DiffusionPipeline. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).

call[[diffusers.Kandinsky6SRPipeline.call]]

__call__(video: typing.Union[list[PIL.Image.Image], list[list[PIL.Image.Image]], numpy.ndarray, torch.Tensor], resolution_scale: float = 2.25, num_inference_steps: int = 4, timesteps: list[int] | None = None, sigmas: list[float] | None = None, lq_noise_scale: float = 0.7, min_overlap: float = 0.2, tiles_batch_size: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'pil', return_dict: bool = True)

Sumber

Parameter:

video (list[PIL.Image.Image], np.ndarray atau torch.Tensor) : Video beresolusi rendah, dalam format apa pun yang diterima oleh preprocess_video(), dengan 1 + k * 4 frame. Ukuran dibulatkan ke bawah menjadi kelipatan dari faktor spasial VAE.

resolution_scale (float, defaultnya 2.25) : Total upscale spasial: 2, 4, atau 2.25 (pre-upscale bilinear 1.125x diikuti jalur 2x).

num_inference_steps (int, defaultnya 4) : Jumlah langkah denoising per tile. Gunakan 2 dengan checkpoint yang telah didistilasi.

timesteps (list[int], opsional) : Timesteps kustom untuk scheduler yang mendukungnya.

sigmas (list[float], opsional) : Sigma kustom untuk scheduler yang mendukungnya.

lq_noise_scale (float, defaultnya 0.7) : Jumlah noise Gaussian yang dicampurkan ke dalam latens resolusi rendah (variance preserving) sebelum denoising.

min_overlap (float, defaultnya 0.2) : Tumpang tindih minimum antara ubin tetangga sebagai fraksi dari ukuran ubin.

tiles_batch_size (int, defaultnya 1) : Jumlah tile yang didenois per panggilan transformer.

generator (torch.Generator atau list[torch.Generator], opsional) : Generator yang digunakan untuk noise yang dicampurkan ke dalam tile.

output_type (str, defaultnya "pil") : Format output dari video yang dihasilkan: "pil", "np" atau "pt".

return_dict (bool, defaultnya True) : Apakah akan mengembalikan Kandinsky6SRPipelineOutput alih-alih tuple biasa.

Mengembalikan: Kandinsky6SRPipelineOutput atau tuple

Video super-resolved; tuple satu elemen ketika return_dict=False.

Fungsi panggilan untuk pipeline super-resolution.

Contoh:

>>> import torch
>>> from diffusers import Kandinsky6SRPipeline, Kandinsky6TI2VAPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = Kandinsky6TI2VAPipeline.from_pretrained(
...     "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", torch_dtype=torch.bfloat16
... )
>>> pipe.enable_model_cpu_offload()
>>> video = pipe(
...     prompt="A cat and a dog baking a cake together in a kitchen.",
...     height=480,
...     width=864,
...     num_inference_steps=16,
...     guidance_scale=1.0,
...     sample_audio=False,
... ).frames[0]

>>> sr_pipe = Kandinsky6SRPipeline.from_pretrained(
...     "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", torch_dtype=torch.bfloat16
... )
>>> # The transformer always runs attention through the `flex` backend; compiling avoids the eager
>>> # fallback's much higher memory use at video resolutions.
>>> sr_pipe.transformer.compile_repeated_blocks(fullgraph=True)
>>> sr_pipe.enable_model_cpu_offload()
>>> output = sr_pipe(video=video, resolution_scale=2.25, num_inference_steps=2)
>>> export_to_video(output.frames[0], "output_sr.mp4", fps=24)

decode_latents[[diffusers.Kandinsky6SRPipeline.decode_latents]]

decode_latents(latents: Tensor)

Sumber

Mendekode latens K-VAE yang diskalakan menjadi video (batch_size, channels, num_frames, height, width) dalam [-1, 1].

encode_video[[diffusers.Kandinsky6SRPipeline.encode_video]]

encode_video(video: Tensor)

Sumber

Mengkodekan video (batch_size, channels, num_frames, height, width) dalam [-1, 1] menjadi latents K-VAE yang diskalakan oleh scaling_factor VAE.

Kandinsky6SRLatentUpscalerBank[[diffusers.Kandinsky6SRLatentUpscalerBank]]

diffusers.Kandinsky6SRLatentUpscalerBank[[diffusers.Kandinsky6SRLatentUpscalerBank]]

diffusers.Kandinsky6SRLatentUpscalerBank(in_channels: int = 64, stage_channels: tuple[int, int, int] = (2048, 1024, 512), num_pre_blocks: int = 5, num_mid_blocks: int = 3, num_post_blocks: int = 3, num_x2_adapter_blocks: int = 2, scales: tuple[int, ...] = (2, 4), scaling_factor: float = 0.910344004631042)

Sumber

Parameter:

in_channels (int, defaultnya 64) : Jumlah kanal laten.

stage_channels (tuple[int, int, int], defaultnya (2048, 1024, 512)) : Lebar fitur dari tiga tahap kaskade.

num_pre_blocks (int, defaultnya 5) : Blok residual sebelum upsample pertama pada model x4.

num_mid_blocks (int, defaultnya 3) : Blok residual di antara dua upsamples.

num_post_blocks (int, defaultnya 3) : Blok residual setelah upsample terakhir.

num_x2_adapter_blocks (int, defaultnya 2) : Blok residual dari adapter model x2.

scales (tuple[int, ...], defaultnya (2, 4)) : Skala spasial yang bank sediakan untuk upscaler.

scaling_factor (float, defaultnya 0.910344) : Skala yang diharapkan dibawa oleh latens input (faktor scaling_factor K-VAE).

Bank upscaler laten yang digunakan oleh Kandinsky6SRPipeline: satu Kandinsky6SRLatentUpscaler untuk setiap skala spasial yang didukung, beroperasi pada laten K-VAE.

forward[[diffusers.Kandinsky6SRLatentUpscalerBank.forward]]

forward(latents: Tensor, scale: int, return_dict: bool = True)

Sumber

Parameter:

latents (torch.Tensor dengan bentuk (batch_size, in_channels, num_frames, height, width)) : Laten K-VAE yang diskalakan dengan scaling_factor.

scale (int) : Faktor upscale spasial; salah satu dari scales.

return_dict (bool, defaultnya True) : Apakah akan mengembalikan ~models.autoencoder_kl.DecoderOutput alih-alih tuple biasa.

Mengembalikan:

Latent yang di-upscale dengan bentuk (batch_size, in_channels, num_frames, height * scale, width * scale).

Kandinsky6TI2VAPipelineOutput[[diffusers.Kandinsky6TI2VAPipelineOutput]]

diffusers.Kandinsky6TI2VAPipelineOutput[[diffusers.Kandinsky6TI2VAPipelineOutput]]

diffusers.Kandinsky6TI2VAPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]], audio: typing.Union[torch.Tensor, numpy.ndarray, NoneType] = None)

Sumber

Parameter:

frames (torch.Tensor, np.ndarray, atau list[list[PIL.Image.Image]]) : Video yang dihasilkan. Daftar bersarang dengan panjang batch_size yang berisi num_frames gambar PIL masing-masing, atau array NumPy atau tensor torch dengan bentuk (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width). Dengan output_type="latent", latens video dengan bentuk (batch_size, channels, num_latent_frames, latent_height, latent_width).

audio (torch.Tensor atau np.ndarray, opsional) : Gelombang yang dihasilkan dengan bentuk (batch_size, num_samples) dalam [-1, 1] pada laju sampel VAE audio, atau None ketika audio tidak disampelkan. Dengan output_type="latent", latens audio dengan bentuk (batch_size, channels, audio_length).

Kelas output untuk Kandinsky6TI2VAPipeline.

Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput[[diffusers.Kandinsky6SRPipelineOutput]]

diffusers.Kandinsky6SRPipelineOutput(frames: typing.Union[torch.Tensor, numpy.ndarray, list[list[PIL.Image.Image]]])

Sumber

Parameter:

frames (torch.Tensor, np.ndarray, atau list[list[PIL.Image.Image]]) : Video yang telah di-super-resolve. Daftar bersarang dengan panjang batch_size yang masing-masing berisi num_frames gambar PIL, atau array NumPy atau tensor torch dengan bentuk (batch_size, num_frames, height, width, channels) / (batch_size, num_frames, channels, height, width).

Kelas output untuk Kandinsky6SRPipeline.