Skip to content

vllm_omni.diffusion.models.longcat_video

Modules:

Name Description
longcat_video_avatar_transformer
pipeline_longcat_video_avatar

LongCatVideoAvatarPipeline

Bases: Module, SupportImageInput, SupportAudioInput

Native LongCat-Video-Avatar A2V/AI2V pipeline.

audio_stride instance-attribute

audio_stride = 1

build_components_on_gpu instance-attribute

build_components_on_gpu = _as_bool(
    additional_config.get("build_components_on_gpu"), False
)

default_num_frames instance-attribute

default_num_frames = 93

device instance-attribute

device = get_local_device()

do_classifier_free_guidance property

do_classifier_free_guidance

dummy_run_num_frames class-attribute

dummy_run_num_frames: int = 1

model_dir instance-attribute

model_dir = _ensure_local_dir(
    od_config.model,
    allow_patterns=_avatar_model_allow_patterns(
        self.use_int8
    ),
)

model_type instance-attribute

model_type = str(
    additional_config.get("model_type") or "avatar-v1.5"
)

num_distill_sample_steps property

num_distill_sample_steps

num_timesteps property

num_timesteps

od_config instance-attribute

od_config = od_config

resolution instance-attribute

resolution = str(
    additional_config.get("resolution") or "480p"
)

save_fps instance-attribute

save_fps = 25

support_audio_input class-attribute

support_audio_input: bool = True

support_image_input class-attribute

support_image_input: bool = True

use_distill instance-attribute

use_distill = _as_bool(
    additional_config.get("use_distill"), True
)

use_int8 instance-attribute

use_int8 = _as_bool(additional_config.get("use_int8"), True)

video_processor instance-attribute

video_processor = VideoProcessor(vae_scale_factor=8)

weights_sources instance-attribute

weights_sources = [
    DiffusersPipelineLoader.ComponentSource(
        model_or_path=str(self.model_dir),
        subfolder=dit_subfolder,
        revision=None,
        prefix="transformer.",
        fall_back_to_pt=False,
    )
]

denormalize_latents

denormalize_latents(latents)

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,
    max_sequence_length: int = 512,
    device: device | None = None,
    dtype: dtype | None = None,
)

forward

get_timesteps_sigmas

get_timesteps_sigmas(
    sampling_steps: int, use_distill: bool = False
) -> Tensor

load_weights

load_weights(
    weights: Iterable[tuple[str, Tensor]],
) -> set[str]

Load DiT weights using vLLM's diffusion weight loader.

normalize_latents

normalize_latents(latents)

prepare_latents

prepare_latents(
    image: Tensor | None,
    batch_size: int,
    num_channels_latents: int,
    height: int,
    width: int,
    num_frames: int,
    num_cond_frames: int,
    dtype: dtype,
    device: device,
    generator: Generator | list[Generator] | None = None,
    latents: Tensor | None = None,
    video: Tensor | None = None,
    need_encode: bool = True,
) -> Tensor

to

to(*args, **kwargs)

LongCatVideoAvatarTransformer3DModel

Bases: Module

active_loras instance-attribute

active_loras = []

audio_proj instance-attribute

audio_proj = AudioProjModel(
    seq_len=audio_window,
    seq_len_vf=audio_window + vae_scale - 1,
    blocks=audio_block,
    channels=audio_channel,
    intermediate_dim=intermediate_dim,
    output_dim=output_dim,
    context_tokens=context_tokens,
)

audio_window instance-attribute

audio_window = audio_window

blocks instance-attribute

blocks = nn.ModuleList(
    [
        LongCatAvatarSingleStreamBlock(
            hidden_size=hidden_size,
            num_heads=num_heads,
            mlp_ratio=mlp_ratio,
            adaln_tembed_dim=adaln_tembed_dim,
            enable_flashattn3=enable_flashattn3,
            enable_flashattn2=enable_flashattn2,
            enable_xformers=enable_xformers,
            enable_bsa=enable_bsa,
            bsa_params=bsa_params,
            cp_split_hw=self.cp_split_hw,
            output_dim=output_dim,
            audio_prenorm=audio_prenorm,
            class_range=class_range,
            class_interval=class_interval,
        )
        for _ in range(depth)
    ]
)

config instance-attribute

config = SimpleNamespace(
    in_channels=in_channels,
    out_channels=out_channels,
    hidden_size=hidden_size,
    depth=depth,
    num_heads=num_heads,
    caption_channels=caption_channels,
    mlp_ratio=mlp_ratio,
    adaln_tembed_dim=adaln_tembed_dim,
    frequency_embedding_size=frequency_embedding_size,
    patch_size=self.patch_size,
    enable_flashattn3=enable_flashattn3,
    enable_flashattn2=enable_flashattn2,
    enable_xformers=enable_xformers,
    enable_bsa=enable_bsa,
    bsa_params=bsa_params,
    cp_split_hw=None,
    text_tokens_zero_pad=text_tokens_zero_pad,
    audio_window=audio_window,
    audio_block=audio_block,
    audio_channel=audio_channel,
    intermediate_dim=intermediate_dim,
    output_dim=output_dim,
    context_tokens=context_tokens,
    vae_scale=vae_scale,
    audio_prenorm=audio_prenorm,
    class_range=class_range,
    class_interval=class_interval,
)

cp_split_hw instance-attribute

cp_split_hw = (1, 1)

dtype property

dtype: dtype

final_layer instance-attribute

final_layer = FinalLayer_FP32(
    hidden_size,
    np.prod(self.patch_size),
    out_channels,
    adaln_tembed_dim,
)

gradient_checkpointing instance-attribute

gradient_checkpointing = False

in_channels instance-attribute

in_channels = in_channels

lora_dict instance-attribute

lora_dict = {}

out_channels instance-attribute

out_channels = out_channels

patch_size instance-attribute

patch_size = tuple(patch_size)

t_embedder instance-attribute

t_embedder = TimestepEmbedder(
    t_embed_dim=adaln_tembed_dim,
    frequency_embedding_size=frequency_embedding_size,
)

text_tokens_zero_pad instance-attribute

text_tokens_zero_pad = text_tokens_zero_pad

vae_scale instance-attribute

vae_scale = vae_scale

x_embedder instance-attribute

x_embedder = PatchEmbed3D(
    self.patch_size, in_channels, hidden_size
)

y_embedder instance-attribute

y_embedder = CaptionEmbedder(
    in_channels=caption_channels, hidden_size=hidden_size
)

disable_all_loras

disable_all_loras()

disable_bsa

disable_bsa()

enable_bsa

enable_bsa()

enable_loras

enable_loras(lora_key_list=None)

forward

forward(
    hidden_states,
    timestep,
    encoder_hidden_states,
    encoder_attention_mask=None,
    num_cond_latents=0,
    return_kv=False,
    kv_cache_dict=None,
    skip_crs_attn=False,
    offload_kv_cache=False,
    audio_embs=None,
    num_ref_latents=None,
    ref_img_index=None,
    mask_frame_range=None,
    ref_target_masks=None,
)

load_lora

load_lora(
    lora_path,
    lora_key,
    multiplier=1.0,
    lora_network_dim=128,
    lora_network_alpha=64,
)

load_weights

load_weights(
    weights: Iterable[tuple[str, Tensor]],
) -> set[str]

unpatchify

unpatchify(x, n_t, n_h, n_w)

get_longcat_video_avatar_post_process_func

get_longcat_video_avatar_post_process_func(
    od_config: OmniDiffusionConfig,
)

get_longcat_video_avatar_pre_process_func

get_longcat_video_avatar_pre_process_func(
    od_config: OmniDiffusionConfig,
)