Skip to content
FastVideo
Esc
↑↓navigate↵open⌘Jpreview
On this page

kandinsky5

fastvideo.configs.pipelines.kandinsky5.DiTConfig

DiTConfig(arch_config: DiTArchConfig = DiTArchConfig(), prefix: str = '', quant_config: QuantizationConfig | None = None, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.configs.pipelines.kandinsky5.DiTConfig.add_cli_args

add_cli_args(parser: Any, prefix: str = 'dit-config') -> Any

Add CLI arguments for DiTConfig fields

fastvideo.configs.pipelines.kandinsky5.EncoderConfig

EncoderConfig(arch_config: ArchConfig = EncoderArchConfig(), prefix: str = '', quant_config: QuantizationConfig | None = None, lora_config: Any | None = None, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.configs.pipelines.kandinsky5.VAEConfig

VAEConfig(arch_config: VAEArchConfig = VAEArchConfig(), load_encoder: bool = True, load_decoder: bool = True, tile_sample_min_height: int = 256, tile_sample_min_width: int = 256, tile_sample_min_num_frames: int = 16, tile_sample_stride_height: int = 192, tile_sample_stride_width: int = 192, tile_sample_stride_num_frames: int = 12, blend_num_frames: int = 0, use_tiling: bool = True, use_temporal_tiling: bool = True, use_parallel_tiling: bool = True, use_temporal_scaling_frames: bool = True, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.configs.pipelines.kandinsky5.VAEConfig.add_cli_args

add_cli_args(parser: Any, prefix: str = 'vae-config') -> Any

Add CLI arguments for VAEConfig fields

fastvideo.configs.pipelines.kandinsky5.VAEConfig.from_cli_args

from_cli_args(args: argparse.Namespace) -> VAEConfig

fastvideo.configs.pipelines.kandinsky5.Kandinsky5VideoConfig

Kandinsky5VideoConfig(arch_config: DiTArchConfig = Kandinsky5ArchConfig(), prefix: str = 'Kandinsky5', quant_config: QuantizationConfig | None = None, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.configs.pipelines.kandinsky5.BaseEncoderOutput

BaseEncoderOutput(last_hidden_state: torch.FloatTensor | None = None, pooler_output: torch.FloatTensor | None = None, hidden_states: tuple[torch.FloatTensor, ...] | None = None, attentions: tuple[torch.FloatTensor, ...] | None = None, attention_mask: torch.Tensor | None = None)

fastvideo.configs.pipelines.kandinsky5.CLIPTextConfig

CLIPTextConfig(arch_config: TextEncoderArchConfig = CLIPTextArchConfig(), prefix: str = 'clip', quant_config: QuantizationConfig | None = None, lora_config: Any | None = None, is_chat_model: bool = False, treat_empty_as_dot: bool = False, num_hidden_layers_override: int | None = None, require_post_norm: bool | None = None, enable_scale: bool = True, is_causal: bool = True, *, _resolved_attention_backend: AttentionBackendEnum | None = None, chat_template_enable_thinking: bool = False)

fastvideo.configs.pipelines.kandinsky5.Reason1Config

Reason1Config(arch_config: Reason1ArchConfig = Reason1ArchConfig(), prefix: str = '', quant_config: QuantizationConfig | None = None, lora_config: Any | None = None, is_chat_model: bool = False, treat_empty_as_dot: bool = False, tokenizer_type: str = 'Qwen/Qwen2.5-VL-7B-Instruct', *, _resolved_attention_backend: AttentionBackendEnum | None = None, chat_template_enable_thinking: bool = False)

Reason1 text encoder config.

fastvideo.configs.pipelines.kandinsky5.HunyuanVAEConfig

HunyuanVAEConfig(arch_config: VAEArchConfig = HunyuanVAEArchConfig(), load_encoder: bool = True, load_decoder: bool = True, tile_sample_min_height: int = 256, tile_sample_min_width: int = 256, tile_sample_min_num_frames: int = 16, tile_sample_stride_height: int = 192, tile_sample_stride_width: int = 192, tile_sample_stride_num_frames: int = 12, blend_num_frames: int = 0, use_tiling: bool = True, use_temporal_tiling: bool = True, use_parallel_tiling: bool = True, use_temporal_scaling_frames: bool = True, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.configs.pipelines.kandinsky5.PipelineConfig

PipelineConfig(model_path: str = '', pipeline_config_path: str | None = None, embedded_cfg_scale: float = 6.0, flow_shift: float | None = None, flow_shift_sr: float | None = None, disable_autocast: bool = False, scheduler_step_in_fp32: bool = False, is_causal: bool = False, dit_config: DiTConfig = DiTConfig(), dit_precision: str = 'bf16', upsampler_config: UpsamplerConfig = UpsamplerConfig(), upsampler_precision: str = 'fp32', vae_config: VAEConfig = VAEConfig(), vae_precision: str = 'fp32', vae_decode_precision: str | None = None, vae_tiling: bool = True, vae_sp: bool = True, image_encoder_config: EncoderConfig = EncoderConfig(), image_encoder_precision: str = 'fp32', image_encoder_configs: tuple[EncoderConfig, ...] | None = None, image_encoder_precisions: tuple[str, ...] | None = None, text_encoder_configs: tuple[EncoderConfig, ...] = (lambda: (EncoderConfig(),))(), text_encoder_precisions: tuple[str, ...] = (lambda: ('fp32',))(), preprocess_text_funcs: tuple[Callable[[str], str], ...] = (lambda: (preprocess_text,))(), postprocess_text_funcs: tuple[Callable[[BaseEncoderOutput], torch.tensor], ...] = (lambda: (postprocess_text,))(), dmd_denoising_steps: list[int] | None = None, ti2v_task: bool = False, lucy_edit_task: bool = False, boundary_ratio: float | None = None)

Base configuration for all pipeline architectures.

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.add_cli_args

add_cli_args(parser: FlexibleArgumentParser, prefix: str = '') -> FlexibleArgumentParser

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.update_config_from_dict

update_config_from_dict(args: dict[str, Any], prefix: str = '') -> None

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.from_pretrained

from_pretrained(model_path: str) -> PipelineConfig

use the pipeline class setting from model_path to match the pipeline config

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.from_kwargs

from_kwargs(kwargs: dict[str, Any], config_cli_prefix: str = '') -> PipelineConfig

Load PipelineConfig from kwargs Dictionary. kwargs: dictionary of kwargs config_cli_prefix: prefix of CLI arguments for this PipelineConfig instance

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.check_pipeline_config

check_pipeline_config() -> None

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.resolve_checkpoint_settings

resolve_checkpoint_settings(fastvideo_args: FastVideoArgs) -> None

Apply the run settings that the checkpoint at fastvideo_args.model_path fixes.

FastVideoArgs.__post_init__ calls this once in the main process, before argument validation and before any weights load. Most checkpoints fix no run settings, so the base implementation does nothing.

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.apply_request_constraints

apply_request_constraints(request: GenerationRequest, sampling_param: SamplingParam) -> SamplingParam

Apply this model's constraints on a generation request to its sampling parameters.

sampling_param holds the preset defaults with the request's explicit fields applied. A model sets the values it fixes when the request leaves them unset, and raises when the request sets a value it does not accept. The base PipelineConfig accepts every request unchanged.

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.dump_to_json

dump_to_json(file_path: str)

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.load_from_json

load_from_json(file_path: str)

fastvideo.configs.pipelines.kandinsky5.PipelineConfig.update_pipeline_config

update_pipeline_config(source_pipeline_dict: dict[str, Any]) -> None

fastvideo.configs.pipelines.kandinsky5.preprocess_text

preprocess_text(prompt: str) -> str

fastvideo.configs.pipelines.kandinsky5.kandinsky5_qwen_preprocess_text

kandinsky5_qwen_preprocess_text(prompt: str) -> str
Source
def kandinsky5_qwen_preprocess_text(prompt: str) -> str:
    if not prompt.strip():
        prompt = "."
    return KANDINSKY5_PROMPT_TEMPLATE.format(prompt)

fastvideo.configs.pipelines.kandinsky5.kandinsky5_qwen_postprocess_text

kandinsky5_qwen_postprocess_text(outputs: BaseEncoderOutput, mask: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]
Source
def kandinsky5_qwen_postprocess_text(outputs: BaseEncoderOutput,
                                     mask: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
    if outputs.hidden_states is None:
        raise RuntimeError("Kandinsky5 Qwen prompt embeddings require hidden_states.")
    hidden_states = outputs.hidden_states[-1]
    prompt_embeds = hidden_states[:, KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX:]
    mask = mask[:, KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX:]
    if prompt_embeds.shape[1] == 0:
        prompt_embeds = hidden_states[:, -1:]
        mask = torch.ones((mask.shape[0], 1), dtype=mask.dtype, device=mask.device)
    return prompt_embeds, mask

fastvideo.configs.pipelines.kandinsky5.kandinsky5_clip_postprocess_text

kandinsky5_clip_postprocess_text(outputs: BaseEncoderOutput) -> torch.Tensor
Source
def kandinsky5_clip_postprocess_text(outputs: BaseEncoderOutput) -> torch.Tensor:
    if outputs.pooler_output is None:
        raise RuntimeError("Kandinsky5 CLIP pooled output is required.")
    return outputs.pooler_output

fastvideo.configs.pipelines.kandinsky5.Kandinsky5T2VConfig

Kandinsky5T2VConfig(model_path: str = '', pipeline_config_path: str | None = None, embedded_cfg_scale: float = 6.0, flow_shift: float | None = 5.0, flow_shift_sr: float | None = None, disable_autocast: bool = False, scheduler_step_in_fp32: bool = False, is_causal: bool = False, dit_config: DiTConfig = Kandinsky5VideoConfig(), dit_precision: str = 'bf16', upsampler_config: UpsamplerConfig = UpsamplerConfig(), upsampler_precision: str = 'fp32', vae_config: VAEConfig = HunyuanVAEConfig(), vae_precision: str = 'bf16', vae_decode_precision: str | None = None, vae_tiling: bool = True, vae_sp: bool = True, image_encoder_config: EncoderConfig = EncoderConfig(), image_encoder_precision: str = 'fp32', image_encoder_configs: tuple[EncoderConfig, ...] | None = None, image_encoder_precisions: tuple[str, ...] | None = None, text_encoder_configs: tuple[EncoderConfig, ...] = (lambda: (Reason1Config(), CLIPTextConfig()))(), text_encoder_precisions: tuple[str, ...] = (lambda: ('bf16', 'bf16'))(), preprocess_text_funcs: tuple[Callable[[str], Any], ...] = (lambda: (kandinsky5_qwen_preprocess_text, preprocess_text))(), postprocess_text_funcs: tuple[Callable[..., Any], ...] = (lambda: (kandinsky5_qwen_postprocess_text, kandinsky5_clip_postprocess_text))(), dmd_denoising_steps: list[int] | None = None, ti2v_task: bool = False, lucy_edit_task: bool = False, boundary_ratio: float | None = None, text_encoder_max_lengths: tuple[int, ...] = (lambda: (KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX + 512, 77))())

Kandinsky-5.0 Lite text-to-video pipeline configuration.

Source
@dataclass
class Kandinsky5T2VConfig(PipelineConfig):
    """Kandinsky-5.0 Lite text-to-video pipeline configuration."""

dit_config: DiTConfig = field(default_factory=Kandinsky5VideoConfig)
vae_config: VAEConfig = field(default_factory=HunyuanVAEConfig)

text_encoder_configs: tuple[EncoderConfig, ...] = field(default_factory=lambda: (Reason1Config(), CLIPTextConfig()))
preprocess_text_funcs: tuple[Callable[[str], Any], ...] = field(
    default_factory=lambda: (kandinsky5_qwen_preprocess_text, preprocess_text))
postprocess_text_funcs: tuple[Callable[..., Any], ...] = field(
    default_factory=lambda: (kandinsky5_qwen_postprocess_text, kandinsky5_clip_postprocess_text))

dit_precision: str = "bf16"
vae_precision: str = "bf16"
text_encoder_precisions: tuple[str, ...] = field(default_factory=lambda: ("bf16", "bf16"))
text_encoder_max_lengths: tuple[int, ...] = field(
    default_factory=lambda: (KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX + 512, 77))

flow_shift: float | None = 5.0
vae_tiling: bool = True

def __post_init__(self) -> None:
    if len(self.text_encoder_configs) != 2:
        raise ValueError(f"Kandinsky5 pipeline requires exactly 2 text encoders (qwen and clip), "
                         f"but got {len(self.text_encoder_configs)} encoder(s).")
    if len(self.text_encoder_precisions) != 2:
        raise ValueError("Kandinsky5 pipeline requires exactly 2 text encoder precisions, "
                         f"but got {len(self.text_encoder_precisions)}.")
    if len(self.text_encoder_max_lengths) != 2:
        raise ValueError("Kandinsky5 pipeline requires exactly 2 text encoder max lengths, "
                         f"but got {len(self.text_encoder_max_lengths)}.")

    self.vae_config.load_encoder = False
    self.vae_config.load_decoder = True

    qwen_cfg = self.text_encoder_configs[0]
    qwen_cfg.arch_config.output_hidden_states = True
    qwen_cfg.arch_config.tokenizer_kwargs.update({
        "padding": True,
        "truncation": True,
        "return_tensors": "pt",
    })

    clip_cfg = self.text_encoder_configs[1]
    clip_cfg.arch_config.tokenizer_kwargs.update({
        "padding": "max_length",
        "max_length": 77,
        "truncation": True,
        "add_special_tokens": True,
        "return_tensors": "pt",
    &#125;)</code></pre></details>


fastvideo.configs.pipelines.kandinsky5.Kandinsky5I2VConfig


Kandinsky5I2VConfig(model_path: str = '', pipeline_config_path: str | None = None, embedded_cfg_scale: float = 6.0, flow_shift: float | None = 5.0, flow_shift_sr: float | None = None, disable_autocast: bool = False, scheduler_step_in_fp32: bool = False, is_causal: bool = False, dit_config: DiTConfig = Kandinsky5VideoConfig(), dit_precision: str = 'bf16', upsampler_config: UpsamplerConfig = UpsamplerConfig(), upsampler_precision: str = 'fp32', vae_config: VAEConfig = HunyuanVAEConfig(), vae_precision: str = 'bf16', vae_decode_precision: str | None = None, vae_tiling: bool = True, vae_sp: bool = True, image_encoder_config: EncoderConfig = EncoderConfig(), image_encoder_precision: str = 'fp32', image_encoder_configs: tuple[EncoderConfig, ...] | None = None, image_encoder_precisions: tuple[str, ...] | None = None, text_encoder_configs: tuple[EncoderConfig, ...] = (lambda: (Reason1Config(), CLIPTextConfig()))(), text_encoder_precisions: tuple[str, ...] = (lambda: ('bf16', 'bf16'))(), preprocess_text_funcs: tuple[Callable[[str], Any], ...] = (lambda: (kandinsky5_qwen_preprocess_text, preprocess_text))(), postprocess_text_funcs: tuple[Callable[..., Any], ...] = (lambda: (kandinsky5_qwen_postprocess_text, kandinsky5_clip_postprocess_text))(), dmd_denoising_steps: list[int] | None = None, ti2v_task: bool = False, lucy_edit_task: bool = False, boundary_ratio: float | None = None, text_encoder_max_lengths: tuple[int, ...] = (lambda: (KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX + 512, 77))())


Kandinsky-5.0 image-to-video pipeline configuration.


Source
@dataclass
class Kandinsky5I2VConfig(Kandinsky5T2VConfig):
    """Kandinsky-5.0 image-to-video pipeline configuration."""

def __post_init__(self) -&gt; None:
    super().__post_init__()
    # I2V needs the VAE encoder to encode the conditioning image.
    self.vae_config.load_encoder = True</code></pre></details>


fastvideo.configs.pipelines.kandinsky5.Kandinsky5DMDConfig


Kandinsky5DMDConfig(model_path: str = '', pipeline_config_path: str | None = None, embedded_cfg_scale: float = 6.0, flow_shift: float | None = 5.0, flow_shift_sr: float | None = None, disable_autocast: bool = False, scheduler_step_in_fp32: bool = False, is_causal: bool = False, dit_config: DiTConfig = Kandinsky5VideoConfig(), dit_precision: str = 'bf16', upsampler_config: UpsamplerConfig = UpsamplerConfig(), upsampler_precision: str = 'fp32', vae_config: VAEConfig = HunyuanVAEConfig(), vae_precision: str = 'bf16', vae_decode_precision: str | None = None, vae_tiling: bool = True, vae_sp: bool = True, image_encoder_config: EncoderConfig = EncoderConfig(), image_encoder_precision: str = 'fp32', image_encoder_configs: tuple[EncoderConfig, ...] | None = None, image_encoder_precisions: tuple[str, ...] | None = None, text_encoder_configs: tuple[EncoderConfig, ...] = (lambda: (Reason1Config(), CLIPTextConfig()))(), text_encoder_precisions: tuple[str, ...] = (lambda: ('bf16', 'bf16'))(), preprocess_text_funcs: tuple[Callable[[str], Any], ...] = (lambda: (kandinsky5_qwen_preprocess_text, preprocess_text))(), postprocess_text_funcs: tuple[Callable[..., Any], ...] = (lambda: (kandinsky5_qwen_postprocess_text, kandinsky5_clip_postprocess_text))(), dmd_denoising_steps: list[int] | None = (lambda: [1000, 750, 500, 250])(), ti2v_task: bool = False, lucy_edit_task: bool = False, boundary_ratio: float | None = None, text_encoder_max_lengths: tuple[int, ...] = (lambda: (KANDINSKY5_PROMPT_TEMPLATE_ENCODE_START_IDX + 512, 77))())


Kandinsky-5.0 DMD (few-step distilled) text-to-video pipeline configuration.


Checkpoints exported by fastvideo.train.entrypoint.dcp_to_diffusers
copy their base T2V checkpoint's model_index.json unchanged, so
_class_name still says the base T2V pipeline and the registry
(fastvideo/registry.py) cannot auto-detect a DMD export -- pass this
config together with override_pipeline_cls_name="Kandinsky5DMDPipeline"
explicitly to VideoGenerator.from_pretrained/from_config (see
examples/train/configs/fine_tuning/kandinsky5/README.md). Without it,
Kandinsky5T2VConfig's dmd_denoising_steps=None makes
Kandinsky5DmdDenoisingStage raise immediately.


Source
@dataclass
class Kandinsky5DMDConfig(Kandinsky5T2VConfig):
    """Kandinsky-5.0 DMD (few-step distilled) text-to-video pipeline configuration.

Checkpoints exported by ``fastvideo.train.entrypoint.dcp_to_diffusers``
copy their base T2V checkpoint&#x27;s ``model_index.json`` unchanged, so
``_class_name`` still says the base T2V pipeline and the registry
(``fastvideo/registry.py``) cannot auto-detect a DMD export -- pass this
config together with ``override_pipeline_cls_name=&quot;Kandinsky5DMDPipeline&quot;``
explicitly to ``VideoGenerator.from_pretrained``/``from_config`` (see
``examples/train/configs/fine_tuning/kandinsky5/README.md``). Without it,
``Kandinsky5T2VConfig``&#x27;s ``dmd_denoising_steps=None`` makes
``Kandinsky5DmdDenoisingStage`` raise immediately.
&quot;&quot;&quot;

dmd_denoising_steps: list&#91;int&#93; | None = field(default_factory=lambda: &#91;1000, 750, 500, 250&#93;)</code></pre></details>

Was this page helpful?