[Refactor] Reject unknown diffusion config fields (#5172)

Signed-off-by: TaffyOfficial <2324465096@qq.com>
Signed-off-by: zuiho <2324465096@qq.com>
Signed-off-by: Gao Han <hgaoaf@connect.ust.hk>
Co-authored-by: TaffyOfficial <2324465096@qq.com>
Co-authored-by: Gao Han <hgaoaf@connect.ust.hk>
This commit is contained in:
authored and GitHub committed 2026-09-19 15:37:34 +00:00
1 parent f90c267ffb
commit 698f716012
13 files changed
+716 -254

No files matched your search

+72 -37
View File
@@ -6,6 +6,7 @@ import json
import math
import os
import random
import warnings
from collections.abc import Callable, Mapping
from dataclasses import dataclass, field, fields
from enum import Enum
@@ -44,55 +45,63 @@ if TYPE_CHECKING:
logger = init_logger(__name__)
def normalize_omni_diffusion_kwargs(raw_kwargs: Mapping[str, Any]) -> dict[str, Any]:
"""Normalize legacy diffusion kwargs before config construction."""
def _move_diffusion_alias(
normalized: dict[str, Any],
legacy_name: str,
canonical_name: str,
) -> None:
legacy_value = normalized.pop(legacy_name, None)
if legacy_value is None:
return
if normalized.get(canonical_name) is not None:
raise ValueError(f"Diffusion config fields {legacy_name!r} and {canonical_name!r} cannot both be provided.")
warnings.warn(
f"Diffusion config field {legacy_name!r} is deprecated; use {canonical_name!r}.",
FutureWarning,
stacklevel=3,
)
normalized[canonical_name] = legacy_value
def normalize_omni_diffusion_kwargs(
raw_kwargs: Mapping[str, Any],
*,
apply_defaults: bool = True,
) -> dict[str, Any]:
"""Normalize diffusion kwargs, deferring defaults until sources are merged."""
config_kwargs = dict(raw_kwargs)
dtype = config_kwargs.get("dtype")
if dtype is None:
config_kwargs["dtype"] = "auto"
if apply_defaults:
config_kwargs["dtype"] = "auto"
elif isinstance(dtype, torch.dtype):
config_kwargs["dtype"] = str(dtype).removeprefix("torch.")
elif not isinstance(dtype, str):
raise TypeError(f"Provided dtype must be a string or torch.dtype, got {type(dtype).__name__}")
# Backwards-compatibility: older callers may use a diffusion-specific
# "static_lora_scale" kwarg. Normalize it to the canonical "lora_scale".
if "static_lora_scale" in config_kwargs:
if "lora_scale" not in config_kwargs:
config_kwargs["lora_scale"] = config_kwargs["static_lora_scale"]
config_kwargs.pop("static_lora_scale", None)
diffusion_quantization = config_kwargs.pop("diffusion_quantization_config", None)
if config_kwargs.get("quantization_config") is None and diffusion_quantization is not None:
config_kwargs["quantization_config"] = diffusion_quantization
# Backwards-compatibility: map "quantization" to "quantization_config"
# so callers using the old field name still work.
if "quantization" in config_kwargs and config_kwargs.get("quantization_config", None) is None:
config_kwargs["quantization_config"] = config_kwargs.pop("quantization")
else:
config_kwargs.pop("quantization", None)
# Renamed from kv_cache_* to avoid clashing with vLLM's --kv-cache-dtype.
if config_kwargs.get("diffusion_kv_cache_dtype") is None and "kv_cache_dtype" in config_kwargs:
config_kwargs["diffusion_kv_cache_dtype"] = config_kwargs.pop("kv_cache_dtype")
else:
config_kwargs.pop("kv_cache_dtype", None)
if config_kwargs.get("diffusion_kv_cache_skip_steps") is None and "kv_cache_skip_steps" in config_kwargs:
config_kwargs["diffusion_kv_cache_skip_steps"] = config_kwargs.pop("kv_cache_skip_steps")
else:
config_kwargs.pop("kv_cache_skip_steps", None)
if config_kwargs.get("diffusion_kv_cache_skip_layers") is None and "kv_cache_skip_layers" in config_kwargs:
config_kwargs["diffusion_kv_cache_skip_layers"] = config_kwargs.pop("kv_cache_skip_layers")
else:
config_kwargs.pop("kv_cache_skip_layers", None)
for legacy, canonical in (
("static_lora_scale", "lora_scale"),
("quantization", "quantization_config"),
("diffusion_quantization_config", "quantization_config"),
("max_batch_size", "max_num_seqs"),
("kv_cache_skip_steps", "diffusion_kv_cache_skip_steps"),
("kv_cache_skip_layers", "diffusion_kv_cache_skip_layers"),
):
_move_diffusion_alias(config_kwargs, legacy, canonical)
_move_diffusion_alias(config_kwargs, "kv_cache_dtype", "diffusion_kv_cache_dtype")
# Handle "diffusion_attention_backend" shorthand: merge into
# diffusion_attention_config before field filtering.
diffusion_attn_backend = config_kwargs.pop("diffusion_attention_backend", None)
fastvideo_vsa_topk = config_kwargs.pop("fastvideo_vsa_topk", None)
if diffusion_attn_backend is not None or fastvideo_vsa_topk is not None:
if diffusion_attn_backend is not None:
warnings.warn(
"Diffusion config field 'diffusion_attention_backend' is deprecated; use 'diffusion_attention_config'.",
FutureWarning,
stacklevel=2,
)
existing = config_kwargs.get("diffusion_attention_config")
config_kwargs["diffusion_attention_config"] = parse_attention_config(
existing,
@@ -100,12 +109,23 @@ def normalize_omni_diffusion_kwargs(raw_kwargs: Mapping[str, Any]) -> dict[str,
fastvideo_vsa_topk=fastvideo_vsa_topk,
)
auxiliary_text_encoder = config_kwargs.pop("auxiliary_text_encoder", None)
if auxiliary_text_encoder is not None:
extras = dict(config_kwargs.get("extras") or {})
if extras.get("auxiliary_text_encoder") is not None:
raise ValueError(
"Diffusion engine field 'auxiliary_text_encoder' cannot be provided both at the top level and in "
"'extras'."
)
extras["auxiliary_text_encoder"] = auxiliary_text_encoder
config_kwargs["extras"] = extras
# Check environment variable as fallback for cache_backend.
# Support both old DIFFUSION_CACHE_ADAPTER and new DIFFUSION_CACHE_BACKEND.
if "cache_backend" not in config_kwargs:
if "cache_backend" not in config_kwargs and apply_defaults:
cache_backend = os.environ.get("DIFFUSION_CACHE_BACKEND") or os.environ.get("DIFFUSION_CACHE_ADAPTER")
config_kwargs["cache_backend"] = cache_backend.lower() if cache_backend else "none"
elif config_kwargs["cache_backend"] is None:
elif "cache_backend" in config_kwargs and config_kwargs["cache_backend"] is None and apply_defaults:
# Callers (e.g. example CLIs with `default=None`) pass an explicit
# None for "no cache"; canonicalize it so every consumer sees the
# declared `str` value instead of relying on per-model None handling.
@@ -162,6 +182,20 @@ def validate_dlo_host_registration_options(
return value
def validate_omni_diffusion_kwargs(
kwargs: Mapping[str, Any],
allowed_fields: set[str] | frozenset[str],
*,
stage_id: int | str | None = None,
) -> None:
"""Reject every field without an owner."""
unknown = set(kwargs) - allowed_fields
if unknown:
names = ", ".join(repr(name) for name in sorted(unknown))
suffix = "" if stage_id is None else f" for stage {stage_id}"
raise ValueError(f"Unknown diffusion config field(s){suffix}: {names}")
def parse_kv_cache_skip_selector(
selector: str | list[int] | tuple[int, ...] | set[int] | None,
) -> set[int] | None:
@@ -1631,8 +1665,9 @@ class OmniDiffusionConfig:
@classmethod
def normalize_init_kwargs(cls, raw_kwargs: Mapping[str, Any]) -> dict[str, Any]:
valid_fields = frozenset(f.name for f in fields(cls))
config_kwargs = normalize_omni_diffusion_kwargs(raw_kwargs)
valid_fields = {f.name for f in fields(cls)}
validate_omni_diffusion_kwargs(config_kwargs, valid_fields)
# Remaining ``None`` values mean "unset" at the CLI/deploy boundary.
# Drop them so non-optional dataclass defaults are not overwritten.
# Fields where ``None`` has normalization semantics (for example dtype