[Config] Read engine args from VllmOmniConfig (#5678)
Signed-off-by: Acerak01-fy <wfy2003324@163.com> Signed-off-by: Wang fuyin <wfy2003324@163.com>
This commit is contained in:
1 parent
6ec9033065
commit
3d7fc3b9ba
6 files changed
+1090
-72
No files matched your search
@@ -39,7 +39,7 @@ from vllm_omni.config.stage_config import (
|
||||
load_deploy_config,
|
||||
merge_pipeline_deploy,
|
||||
)
|
||||
from vllm_omni.engine.stage_init_utils import build_engine_args_dict
|
||||
from vllm_omni.engine.stage_init_utils import build_legacy_engine_args_dict
|
||||
|
||||
pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
|
||||
|
||||
@@ -124,10 +124,16 @@ def test_vllm_omni_config_from_pipeline_config_matches_merge_pipeline_deploy(mod
|
||||
assert omni_stage.model_config.enforce_eager == engine_args.get("enforce_eager", False)
|
||||
assert omni_stage.load_config.load_format == engine_args.get("load_format", "auto")
|
||||
assert omni_stage.load_config.tokenizer_mode == engine_args.get("tokenizer_mode", "auto")
|
||||
assert omni_stage.cache_config.gpu_memory_utilization == engine_args.get("gpu_memory_utilization", 0.90)
|
||||
assert omni_stage.scheduler_config.max_num_seqs == engine_args.get("max_num_seqs", 128)
|
||||
assert omni_stage.cache_config.gpu_memory_utilization == engine_args.get("gpu_memory_utilization")
|
||||
assert omni_stage.cache_config.enable_prefix_caching == engine_args.get("enable_prefix_caching")
|
||||
expected_disable_hybrid = engine_args.get("disable_hybrid_kv_cache_manager")
|
||||
if omni_stage.stage_pipeline_config.execution_type == StageExecutionType.LLM_GENERATION:
|
||||
expected_disable_hybrid = True if expected_disable_hybrid is None else expected_disable_hybrid
|
||||
assert omni_stage.cache_config.disable_hybrid_kv_cache_manager == expected_disable_hybrid
|
||||
assert omni_stage.scheduler_config.max_num_seqs == engine_args.get("max_num_seqs")
|
||||
assert omni_stage.scheduler_config.max_num_batched_tokens == engine_args.get("max_num_batched_tokens")
|
||||
assert omni_stage.scheduler_config.async_scheduling == engine_args.get("async_scheduling", True)
|
||||
assert omni_stage.scheduler_config.enable_chunked_prefill == engine_args.get("enable_chunked_prefill")
|
||||
assert omni_stage.scheduler_config.async_scheduling == engine_args.get("async_scheduling")
|
||||
legacy_parallel_config = engine_args.get("parallel_config") or {}
|
||||
assert omni_stage.parallel_config.tensor_parallel_size == legacy_parallel_config.get(
|
||||
"tensor_parallel_size",
|
||||
@@ -198,6 +204,64 @@ def test_from_pipeline_config_applies_cli_overrides_without_stage_config_runtime
|
||||
assert stage1.runtime_config.num_gpus == stage1.parallel_config.world_size
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"cli_overrides",
|
||||
[
|
||||
{"enable_lora": True},
|
||||
{"stage_0_enable_lora": True},
|
||||
],
|
||||
ids=["global", "stage-scoped"],
|
||||
)
|
||||
def test_from_pipeline_config_rejects_explicit_unowned_engine_cli_fields(cli_overrides):
|
||||
with pytest.raises(ValueError, match=r"no structured config owner: enable_lora"):
|
||||
_from_pipeline_key("qwen3_tts", cli_overrides=cli_overrides)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("engine_extras", "unowned_field"),
|
||||
[
|
||||
({"enable_lora": True}, "enable_lora"),
|
||||
({"parallel_config": {"cfg_parallel_size": 2}}, "parallel_config.cfg_parallel_size"),
|
||||
],
|
||||
ids=["top-level", "nested-parallel-config"],
|
||||
)
|
||||
def test_from_pipeline_config_rejects_unowned_deploy_engine_extras(engine_extras, unowned_field):
|
||||
pipeline = _resolve_pipeline_or_skip("qwen3_tts")
|
||||
deploy = DeployConfig(stages=[StageDeployConfig(stage_id=0, engine_extras=engine_extras)])
|
||||
|
||||
with pytest.raises(ValueError, match=rf"no structured config owner: {unowned_field}"):
|
||||
VllmOmniConfig.from_pipeline_config(pipeline, user_deploy_config=deploy)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("cli_overrides", "stage_id"),
|
||||
[
|
||||
({"kv_cache_dtype": "fp8"}, 0),
|
||||
({"stage_0_kv_cache_dtype": "fp8"}, 0),
|
||||
({"stage_1_kv_cache_dtype": "fp8"}, 1),
|
||||
],
|
||||
ids=["global", "ar-stage", "generation-stage"],
|
||||
)
|
||||
def test_from_pipeline_config_rejects_diffusion_only_cli_fields_for_llm_stages(cli_overrides, stage_id):
|
||||
with pytest.raises(ValueError, match=rf"Stage {stage_id} .*no structured config owner: kv_cache_dtype"):
|
||||
_from_pipeline_key("qwen3_tts", cli_overrides=cli_overrides)
|
||||
|
||||
|
||||
def test_from_pipeline_config_accepts_diffusion_only_cli_fields_for_diffusion_stage():
|
||||
stage = _from_pipeline_key(
|
||||
"dreamzero",
|
||||
deploy_config_path="dreamzero_tp1_cfg2",
|
||||
cli_overrides={"kv_cache_dtype": "fp8"},
|
||||
).stage_by_id(0)
|
||||
|
||||
assert isinstance(stage, VllmOmniDiffusionStageConfig)
|
||||
assert stage.diffusion_config.diffusion_kv_cache_dtype == "fp8"
|
||||
|
||||
|
||||
def test_stage_cli_field_selection_defers_ownership_validation_until_sources_are_merged():
|
||||
assert omni_config_module._stage_cli_overrides(0, {"enable_lora": True}) == {"enable_lora": True}
|
||||
|
||||
|
||||
def test_runtime_num_gpus_is_derived_from_parallel_world_size():
|
||||
omni_config = _from_pipeline_key("hunyuan_image3_dit")
|
||||
stage = omni_config.stage_by_id(0)
|
||||
@@ -380,8 +444,10 @@ def test_vllm_omni_stage_config_public_fields_use_typed_stage_realizations():
|
||||
assert {f.name for f in fields(VllmOmniGenerationStageConfig)} == public_fields
|
||||
|
||||
|
||||
def test_runtime_config_fields_match_rfc_runtime_scope():
|
||||
def test_runtime_config_fields_match_structured_runtime_scope():
|
||||
assert {f.name for f in fields(OmniStageRuntimeConfig)} == {
|
||||
"distributed_executor_backend",
|
||||
"worker_cls",
|
||||
"devices",
|
||||
"num_replicas",
|
||||
"env",
|
||||
@@ -392,8 +458,21 @@ def test_runtime_config_fields_match_rfc_runtime_scope():
|
||||
}
|
||||
|
||||
|
||||
def test_sub_config_fields_match_rfc_scopes():
|
||||
def test_sub_config_fields_match_structured_scopes():
|
||||
assert {f.name for f in fields(OmniStageModelConfig)} == {
|
||||
"model",
|
||||
"model_arch",
|
||||
"revision",
|
||||
"tokenizer_revision",
|
||||
"code_revision",
|
||||
"seed",
|
||||
"logits_processors",
|
||||
"trust_remote_code",
|
||||
"dtype",
|
||||
"attention_backend",
|
||||
"moe_backend",
|
||||
"hf_overrides",
|
||||
"limit_mm_per_prompt",
|
||||
"active_stream_window",
|
||||
"duplex_max_sessions",
|
||||
"enable_sleep_mode",
|
||||
@@ -404,6 +483,7 @@ def test_sub_config_fields_match_rfc_scopes():
|
||||
"task_type",
|
||||
"codec_frame_rate_hz",
|
||||
"enforce_eager",
|
||||
"max_cudagraph_capture_size",
|
||||
"enable_flashinfer_autotune",
|
||||
"compilation_config",
|
||||
"enable_multithread_weight_load",
|
||||
@@ -416,12 +496,16 @@ def test_sub_config_fields_match_rfc_scopes():
|
||||
"tokenizer_subdir",
|
||||
}
|
||||
assert {f.name for f in fields(OmniStageLoadConfig)} == {
|
||||
"tokenizer",
|
||||
"download_dir",
|
||||
"skip_tokenizer_init",
|
||||
"load_format",
|
||||
"tokenizer_mode",
|
||||
"config_format",
|
||||
"skip_mm_profiling",
|
||||
}
|
||||
assert {f.name for f in fields(OmniStageCacheConfig)} == {
|
||||
"kv_cache_memory_bytes",
|
||||
"gpu_memory_utilization",
|
||||
"enable_prefix_caching",
|
||||
"disable_hybrid_kv_cache_manager",
|
||||
@@ -435,6 +519,8 @@ def test_sub_config_fields_match_rfc_scopes():
|
||||
"async_scheduling",
|
||||
}
|
||||
assert {f.name for f in fields(OmniStageConnectorConfig)} == {
|
||||
"async_chunk",
|
||||
"omni_kv_config",
|
||||
"stage_connector",
|
||||
"output_connectors",
|
||||
"input_connectors",
|
||||
@@ -827,7 +913,7 @@ def test_from_pipeline_config_matches_build_engine_args_dict_behavior_for_repres
|
||||
pipeline = _resolve_pipeline_or_skip("qwen3_tts")
|
||||
legacy_stage = merge_pipeline_deploy(pipeline, _load_default_deploy(pipeline))[0]
|
||||
omega_stage = legacy_stage.to_omegaconf()
|
||||
legacy_engine_args = build_engine_args_dict(
|
||||
legacy_engine_args = build_legacy_engine_args_dict(
|
||||
omega_stage,
|
||||
model="/tmp/qwen3-tts",
|
||||
stage_connector_spec={"name": "SharedMemoryConnector", "extra": {}},
|
||||
@@ -922,6 +1008,8 @@ def test_from_pipeline_config_normalizes_diffusion_config_aliases_from_engine_ar
|
||||
|
||||
|
||||
def test_diffusion_config_field_classification_covers_current_fields():
|
||||
from vllm_omni.diffusion.data import OmniDiffusionConfig
|
||||
|
||||
classified_fields = (
|
||||
omni_config_module._DIFFUSION_SHARED_CONFIG_FIELDS
|
||||
| omni_config_module._DIFFUSION_RUNTIME_CONFIG_FIELDS
|
||||
@@ -929,8 +1017,12 @@ def test_diffusion_config_field_classification_covers_current_fields():
|
||||
)
|
||||
|
||||
assert classified_fields == {f.name for f in fields(omni_config_module._DiffusionConfigProjection)}
|
||||
assert {f.name for f in fields(OmniDiffusionConfig)} <= (
|
||||
classified_fields | omni_config_module._DIFFUSION_MOVED_SHARED_FIELDS
|
||||
)
|
||||
assert {
|
||||
"enable_prompt_embed_cache",
|
||||
"enable_session_state_manager",
|
||||
"prompt_embed_cache_size",
|
||||
"diffusion_kv_cache_dtype",
|
||||
} <= omni_config_module._DIFFUSION_ONLY_CONFIG_FIELDS
|
||||
|
||||
@@ -0,0 +1,510 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import sys
|
||||
import types
|
||||
from dataclasses import fields, replace
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from pydantic.fields import FieldInfo
|
||||
|
||||
from vllm_omni.config.omni_config import VllmOmniConfig
|
||||
from vllm_omni.config.pipeline_registry import OMNI_PIPELINES, resolve_pipeline_config
|
||||
from vllm_omni.config.stage_config import (
|
||||
DeployConfig,
|
||||
PipelineConfig,
|
||||
StageDeployConfig,
|
||||
StageExecutionType,
|
||||
StagePipelineConfig,
|
||||
StageType,
|
||||
build_stage_runtime_overrides,
|
||||
load_deploy_config,
|
||||
merge_pipeline_deploy,
|
||||
)
|
||||
from vllm_omni.diffusion.data import AttentionConfig, OmniDiffusionConfig
|
||||
from vllm_omni.engine import stage_init_utils
|
||||
from vllm_omni.engine.arg_utils import OmniEngineArgs
|
||||
from vllm_omni.engine.stage_init_utils import (
|
||||
build_engine_args_dict,
|
||||
build_engine_args_dict_from_omni_stage_config,
|
||||
build_legacy_engine_args_dict,
|
||||
)
|
||||
|
||||
pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
|
||||
|
||||
_DEPLOY_DIR = Path(__file__).parents[2] / "vllm_omni" / "deploy"
|
||||
|
||||
|
||||
def _effective_backend_values(config_cls: type, engine_args: dict) -> dict[str, object]:
|
||||
backend_fields = fields(config_cls)
|
||||
backend_field_names = {backend_field.name for backend_field in backend_fields}
|
||||
backend_config = config_cls(
|
||||
**{name: copy.deepcopy(value) for name, value in engine_args.items() if name in backend_field_names}
|
||||
)
|
||||
effective_values: dict[str, object] = {}
|
||||
for backend_field in backend_fields:
|
||||
value = getattr(backend_config, backend_field.name)
|
||||
if isinstance(value, FieldInfo):
|
||||
value = value.get_default(call_default_factory=True)
|
||||
effective_values[backend_field.name] = value
|
||||
return effective_values
|
||||
|
||||
|
||||
_LLM_BACKEND_FIELDS = frozenset(field.name for field in fields(OmniEngineArgs))
|
||||
_DIFFUSION_BACKEND_FIELDS = frozenset(field.name for field in fields(OmniDiffusionConfig))
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _stable_engine_arg_environment(monkeypatch, tmp_path):
|
||||
from vllm_omni import platforms
|
||||
|
||||
monkeypatch.delenv("VLLM_USE_FLASHINFER_MOE_FP16", raising=False)
|
||||
xcodec_model = tmp_path / "xcodec-model"
|
||||
xcodec_model.mkdir()
|
||||
monkeypatch.setenv("XCODEC1_PATH", str(xcodec_model))
|
||||
platform = platforms.current_omni_platform
|
||||
monkeypatch.setattr(platform, "device_name", "cpu", raising=False)
|
||||
monkeypatch.setattr(platform, "device_type", "cpu", raising=False)
|
||||
monkeypatch.setattr(platform, "is_rocm", lambda: False)
|
||||
monkeypatch.setattr(
|
||||
OmniDiffusionConfig,
|
||||
"_resolve_master_port",
|
||||
lambda config: config.master_port or 29500,
|
||||
)
|
||||
|
||||
def _resolve_test_worker(engine_args):
|
||||
worker_type = engine_args.get("worker_type")
|
||||
if worker_type is not None and engine_args.get("worker_cls") in (None, "auto"):
|
||||
engine_args["worker_cls"] = f"test.{worker_type}.Worker"
|
||||
|
||||
monkeypatch.setattr(stage_init_utils, "resolve_worker_cls", _resolve_test_worker)
|
||||
|
||||
|
||||
def _engine_arg_inputs(tmp_path: Path) -> tuple[PipelineConfig, DeployConfig, str]:
|
||||
parent_model = tmp_path / "parent-model"
|
||||
stage_model = tmp_path / "stage-model"
|
||||
diffusion_model = tmp_path / "diffusion-model"
|
||||
for root in (parent_model, stage_model, diffusion_model):
|
||||
root.mkdir()
|
||||
(stage_model / "ar-model").mkdir()
|
||||
(stage_model / "ar-tokenizer").mkdir()
|
||||
|
||||
pipeline = PipelineConfig(
|
||||
model_type="typed-engine-args",
|
||||
model_arch="PipelineModel",
|
||||
stages=(
|
||||
StagePipelineConfig(
|
||||
stage_id=0,
|
||||
model_stage="thinker",
|
||||
execution_type=StageExecutionType.LLM_AR,
|
||||
requires_multimodal_data=True,
|
||||
hf_config_name="thinker_config",
|
||||
engine_output_type="hidden_states",
|
||||
model_arch="Qwen3OmniMoeForConditionalGeneration",
|
||||
model_subdir="ar-model",
|
||||
tokenizer_subdir="ar-tokenizer",
|
||||
retains_state_across_chunks=True,
|
||||
async_chunk_process_next_stage_input_func="operator.add",
|
||||
),
|
||||
StagePipelineConfig(
|
||||
stage_id=1,
|
||||
model_stage="talker",
|
||||
execution_type=StageExecutionType.LLM_GENERATION,
|
||||
input_sources=(0,),
|
||||
engine_output_type="audio_tokens",
|
||||
),
|
||||
StagePipelineConfig(
|
||||
stage_id=2,
|
||||
model_stage="dit",
|
||||
execution_type=StageExecutionType.DIFFUSION,
|
||||
input_sources=(1,),
|
||||
final_output=True,
|
||||
final_output_type="image",
|
||||
model_arch="TypedDiffusionPipeline",
|
||||
),
|
||||
),
|
||||
)
|
||||
deploy = DeployConfig(
|
||||
async_chunk=True,
|
||||
trust_remote_code=True,
|
||||
dtype="float16",
|
||||
distributed_executor_backend="mp",
|
||||
stages=[
|
||||
StageDeployConfig(
|
||||
stage_id=0,
|
||||
tensor_parallel_size=2,
|
||||
max_num_seqs=8,
|
||||
default_sampling_params={"extra_args": {"voice": "test"}},
|
||||
engine_extras={
|
||||
"model": str(stage_model),
|
||||
"attention_backend": "FLASHINFER",
|
||||
"hf_overrides": {"rope_scaling": {"factor": 2}},
|
||||
"limit_mm_per_prompt": {"audio": 1},
|
||||
"logits_processors": ["test.custom.LogitsProcessor"],
|
||||
"kv_cache_memory_bytes": 1024,
|
||||
"omni_kv_config": {"need_send_cache": True},
|
||||
"max_cudagraph_capture_size": 0,
|
||||
"worker_cls": "test.custom.Worker",
|
||||
},
|
||||
),
|
||||
StageDeployConfig(
|
||||
stage_id=1,
|
||||
max_num_seqs=4,
|
||||
),
|
||||
StageDeployConfig(
|
||||
stage_id=2,
|
||||
tensor_parallel_size=2,
|
||||
vae_parallel_mode="spatial_shard_height",
|
||||
diffusion_attention_config={
|
||||
"default": {"backend": "FLASH_ATTN"},
|
||||
"per_role": {"cross": {"backend": "TORCH_SDPA"}},
|
||||
},
|
||||
engine_extras={
|
||||
"model": str(diffusion_model),
|
||||
"engine_backend": "test.diffusion.Engine",
|
||||
"enable_session_state_manager": True,
|
||||
},
|
||||
),
|
||||
],
|
||||
)
|
||||
return pipeline, deploy, str(parent_model)
|
||||
|
||||
|
||||
def _legacy_and_typed_stages(
|
||||
pipeline: PipelineConfig,
|
||||
deploy: DeployConfig,
|
||||
model: str,
|
||||
cli_overrides: dict[str, object] | None = None,
|
||||
):
|
||||
resolved_cli_overrides = {"model": model, **(cli_overrides or {})}
|
||||
legacy_stage_configs = merge_pipeline_deploy(
|
||||
pipeline,
|
||||
copy.deepcopy(deploy),
|
||||
)
|
||||
for stage in legacy_stage_configs:
|
||||
stage.runtime_overrides = build_stage_runtime_overrides(
|
||||
stage.stage_id,
|
||||
resolved_cli_overrides,
|
||||
)
|
||||
legacy_stages = [stage.to_omegaconf() for stage in legacy_stage_configs]
|
||||
omni_config = VllmOmniConfig.from_pipeline_config(
|
||||
pipeline,
|
||||
user_deploy_config=copy.deepcopy(deploy),
|
||||
cli_overrides=resolved_cli_overrides,
|
||||
)
|
||||
return legacy_stages, omni_config
|
||||
|
||||
|
||||
def test_typed_llm_engine_args_preserve_legacy_adapter_behavior(tmp_path):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
|
||||
connector_spec = {"name": "SharedMemoryConnector", "extra": {"mode": "test"}}
|
||||
cli_tokenizer = "/external/tokenizer"
|
||||
|
||||
typed_args_by_stage = {}
|
||||
for stage_id in (0, 1):
|
||||
legacy_args = build_legacy_engine_args_dict(
|
||||
legacy_stages[stage_id],
|
||||
model,
|
||||
stage_connector_spec=connector_spec,
|
||||
cli_tokenizer=cli_tokenizer,
|
||||
)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(stage_id),
|
||||
model,
|
||||
stage_connector_spec=connector_spec,
|
||||
cli_tokenizer=cli_tokenizer,
|
||||
)
|
||||
typed_args_by_stage[stage_id] = typed_args
|
||||
|
||||
assert {name: typed_args[name] for name in legacy_args} == legacy_args
|
||||
|
||||
thinker_args = typed_args_by_stage[0]
|
||||
assert thinker_args["model"] == str(tmp_path / "stage-model" / "ar-model")
|
||||
assert thinker_args["tokenizer"] == str(tmp_path / "stage-model" / "ar-tokenizer")
|
||||
assert thinker_args["stage_id"] == 0
|
||||
assert thinker_args["stage_connector_spec"] == connector_spec
|
||||
assert thinker_args["has_sampling_extra_args"] is True
|
||||
assert thinker_args["omni_kv_config"] == {"need_send_cache": True}
|
||||
assert thinker_args["worker_cls"] == "test.custom.Worker"
|
||||
assert thinker_args["attention_backend"] == "FLASHINFER"
|
||||
assert thinker_args["trust_remote_code"] is True
|
||||
assert thinker_args["dtype"] == "float16"
|
||||
assert thinker_args["distributed_executor_backend"] == "mp"
|
||||
assert thinker_args["tensor_parallel_size"] == 2
|
||||
assert thinker_args["hf_overrides"] == {"rope_scaling": {"factor": 2}}
|
||||
assert thinker_args["limit_mm_per_prompt"] == {"audio": 1}
|
||||
assert thinker_args["logits_processors"] == ["test.custom.LogitsProcessor"]
|
||||
assert thinker_args["retains_state_across_chunks"] is True
|
||||
assert thinker_args["kv_cache_memory_bytes"] == 1024
|
||||
assert thinker_args["max_cudagraph_capture_size"] == 0
|
||||
|
||||
talker_args = typed_args_by_stage[1]
|
||||
assert talker_args["model"] == model
|
||||
assert talker_args["tokenizer"] == cli_tokenizer
|
||||
assert talker_args["worker_cls"] == "test.generation.Worker"
|
||||
assert talker_args["disable_hybrid_kv_cache_manager"] is True
|
||||
assert talker_args["enable_prefix_caching"] is False
|
||||
|
||||
|
||||
def test_typed_diffusion_engine_args_use_structured_diffusion_config(tmp_path):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
|
||||
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[2], model)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(2),
|
||||
model,
|
||||
)
|
||||
|
||||
assert typed_args["stage_id"] == legacy_args["stage_id"] == 2
|
||||
assert typed_args["model"] == legacy_args["model"] == str(tmp_path / "diffusion-model")
|
||||
assert omni_config.stage_by_id(2).diffusion_config.model == str(tmp_path / "diffusion-model")
|
||||
assert typed_args["model_stage"] == legacy_args["model_stage"] == "dit"
|
||||
assert typed_args["model_arch"] == legacy_args["model_arch"] == "TypedDiffusionPipeline"
|
||||
assert typed_args["model_class_name"] == legacy_args["model_class_name"] == "TypedDiffusionPipeline"
|
||||
assert typed_args["engine_backend"] == legacy_args["engine_backend"] == "test.diffusion.Engine"
|
||||
assert typed_args["enable_session_state_manager"] is legacy_args["enable_session_state_manager"] is True
|
||||
assert typed_args["parallel_config"]["tensor_parallel_size"] == 2
|
||||
assert typed_args["parallel_config"]["vae_parallel_mode"] == "spatial_shard_height"
|
||||
assert isinstance(typed_args["diffusion_attention_config"], AttentionConfig)
|
||||
assert typed_args["diffusion_attention_config"].default.backend == "FLASH_ATTN"
|
||||
assert typed_args["diffusion_attention_config"].per_role["cross"].backend == "TORCH_SDPA"
|
||||
|
||||
|
||||
def test_typed_engine_args_preserve_explicit_backend_default_overrides(tmp_path):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
deploy.enable_prefix_caching = False
|
||||
deploy.enable_chunked_prefill = False
|
||||
thinker_deploy = deploy.stages[0]
|
||||
thinker_deploy.gpu_memory_utilization = 0.75
|
||||
thinker_deploy.disable_hybrid_kv_cache_manager = False
|
||||
thinker_deploy.async_scheduling = False
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
|
||||
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(0),
|
||||
model,
|
||||
)
|
||||
expected = {
|
||||
"gpu_memory_utilization": 0.75,
|
||||
"enable_prefix_caching": False,
|
||||
"disable_hybrid_kv_cache_manager": False,
|
||||
"max_num_seqs": 8,
|
||||
"enable_chunked_prefill": False,
|
||||
"async_scheduling": False,
|
||||
}
|
||||
|
||||
assert {name: legacy_args[name] for name in expected} == expected
|
||||
assert {name: typed_args[name] for name in expected} == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize("stage_scoped", [False, True], ids=["global", "stage-scoped"])
|
||||
def test_typed_engine_args_preserve_inherited_model_and_load_cli_fields(tmp_path, stage_scoped):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
expected = {
|
||||
"revision": "model-rev",
|
||||
"tokenizer_revision": "tokenizer-rev",
|
||||
"code_revision": "code-rev",
|
||||
"seed": 123,
|
||||
"download_dir": str(tmp_path / "downloads"),
|
||||
}
|
||||
cli_overrides = {f"stage_0_{name}" if stage_scoped else name: value for name, value in expected.items()}
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(
|
||||
pipeline,
|
||||
deploy,
|
||||
model,
|
||||
cli_overrides,
|
||||
)
|
||||
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(0),
|
||||
model,
|
||||
)
|
||||
|
||||
assert {name: legacy_args[name] for name in expected} == expected
|
||||
assert {name: typed_args[name] for name in expected} == expected
|
||||
|
||||
|
||||
def test_typed_engine_args_preserve_deploy_subdirectory_precedence(tmp_path):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
stage_model = tmp_path / "stage-model"
|
||||
(stage_model / "override-model").mkdir()
|
||||
(stage_model / "override-tokenizer").mkdir()
|
||||
deploy.stages[0].engine_extras.update(
|
||||
{
|
||||
"model_subdir": "override-model",
|
||||
"tokenizer_subdir": "override-tokenizer",
|
||||
}
|
||||
)
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
|
||||
|
||||
typed_stage = omni_config.stage_by_id(0)
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(typed_stage, model)
|
||||
|
||||
assert typed_stage.model_config.model_subdir == "override-model"
|
||||
assert typed_stage.model_config.tokenizer_subdir == "override-tokenizer"
|
||||
assert typed_args["model"] == legacy_args["model"] == str(stage_model / "override-model")
|
||||
assert typed_args["tokenizer"] == legacy_args["tokenizer"] == str(stage_model / "override-tokenizer")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("cli_overrides", "expected"),
|
||||
[
|
||||
({}, {"need_recv_cache": True}),
|
||||
(
|
||||
{"stage_0_omni_kv_config": {"need_send_cache": False}},
|
||||
{"need_send_cache": False},
|
||||
),
|
||||
],
|
||||
ids=["topology-over-deploy", "cli-over-topology"],
|
||||
)
|
||||
def test_typed_engine_args_preserve_legacy_omni_kv_precedence(tmp_path, cli_overrides, expected):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
thinker = replace(
|
||||
pipeline.stages[0],
|
||||
omni_kv_config={"need_recv_cache": True},
|
||||
)
|
||||
pipeline = replace(pipeline, stages=(thinker, *pipeline.stages[1:]))
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(
|
||||
pipeline,
|
||||
deploy,
|
||||
model,
|
||||
cli_overrides,
|
||||
)
|
||||
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[0], model)
|
||||
typed_stage = omni_config.stage_by_id(0)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(typed_stage, model)
|
||||
|
||||
assert typed_stage.connector_config.omni_kv_config == expected
|
||||
assert typed_args["omni_kv_config"] == legacy_args["omni_kv_config"] == expected
|
||||
|
||||
|
||||
def test_build_engine_args_dict_preserves_legacy_api(tmp_path):
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
legacy_stages, _ = _legacy_and_typed_stages(pipeline, deploy, model)
|
||||
connector_spec = {"name": "SharedMemoryConnector", "extra": {}}
|
||||
|
||||
compatibility_args = build_engine_args_dict(
|
||||
copy.deepcopy(legacy_stages[0]),
|
||||
model,
|
||||
stage_connector_spec=connector_spec,
|
||||
cli_tokenizer="/external/tokenizer",
|
||||
)
|
||||
explicitly_legacy_args = build_legacy_engine_args_dict(
|
||||
copy.deepcopy(legacy_stages[0]),
|
||||
model,
|
||||
stage_connector_spec=connector_spec,
|
||||
cli_tokenizer="/external/tokenizer",
|
||||
)
|
||||
|
||||
assert compatibility_args == explicitly_legacy_args
|
||||
|
||||
|
||||
def test_legacy_engine_args_drop_none_tp_without_mutating_stage_config():
|
||||
stage_config = types.SimpleNamespace(
|
||||
stage_id=0,
|
||||
stage_type="llm",
|
||||
engine_args={"tensor_parallel_size": None},
|
||||
default_sampling_params={},
|
||||
)
|
||||
|
||||
engine_args = build_legacy_engine_args_dict(
|
||||
stage_config,
|
||||
model="test-model",
|
||||
)
|
||||
|
||||
assert "tensor_parallel_size" not in engine_args
|
||||
assert stage_config.engine_args == {"tensor_parallel_size": None}
|
||||
|
||||
|
||||
def test_typed_engine_args_own_rocm_attention_default(monkeypatch, tmp_path):
|
||||
from vllm_omni import platforms
|
||||
|
||||
pipeline, deploy, model = _engine_arg_inputs(tmp_path)
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(pipeline, deploy, model)
|
||||
monkeypatch.setattr(platforms.current_omni_platform, "is_rocm", lambda: True)
|
||||
aiter_module = types.ModuleType("vllm._aiter_ops")
|
||||
setattr(
|
||||
aiter_module,
|
||||
"rocm_aiter_ops",
|
||||
types.SimpleNamespace(is_enabled=lambda: False),
|
||||
)
|
||||
monkeypatch.setitem(sys.modules, "vllm._aiter_ops", aiter_module)
|
||||
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[1], model)
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(1),
|
||||
model,
|
||||
)
|
||||
|
||||
assert "attention_backend" not in legacy_args
|
||||
assert typed_args["attention_backend"] == "TRITON_ATTN"
|
||||
|
||||
|
||||
def test_typed_ming_image_engine_args_defer_diffusion_batch_default():
|
||||
pipeline = resolve_pipeline_config("ming_flash_omni_image")
|
||||
assert pipeline is not None
|
||||
deploy = load_deploy_config(_DEPLOY_DIR / "ming_flash_omni_image.yaml")
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(
|
||||
pipeline,
|
||||
deploy,
|
||||
model="/tmp",
|
||||
)
|
||||
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stages[1], model="/tmp")
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(1),
|
||||
model="/tmp",
|
||||
)
|
||||
typed_backend_args = {name: value for name, value in typed_args.items() if name in _DIFFUSION_BACKEND_FIELDS}
|
||||
|
||||
assert "max_num_seqs" not in legacy_args
|
||||
assert "max_num_seqs" not in typed_args
|
||||
assert OmniDiffusionConfig(**typed_backend_args).max_num_seqs == 1
|
||||
|
||||
|
||||
@pytest.mark.parametrize("model_type", sorted(OMNI_PIPELINES))
|
||||
def test_typed_engine_args_match_current_registry_backend_semantics(model_type):
|
||||
pipeline = resolve_pipeline_config(model_type)
|
||||
if pipeline is None:
|
||||
pytest.skip(f"Pipeline {model_type!r} requires an HF config to resolve")
|
||||
|
||||
deploy = (
|
||||
load_deploy_config(_DEPLOY_DIR / pipeline.default_deploy_config_name)
|
||||
if pipeline.default_deploy_config_name is not None
|
||||
else DeployConfig()
|
||||
)
|
||||
legacy_stages, omni_config = _legacy_and_typed_stages(
|
||||
pipeline,
|
||||
deploy,
|
||||
model="/tmp",
|
||||
)
|
||||
|
||||
for legacy_stage in legacy_stages:
|
||||
stage_id = legacy_stage.stage_id
|
||||
legacy_args = build_legacy_engine_args_dict(legacy_stage, model="/tmp")
|
||||
typed_args = build_engine_args_dict_from_omni_stage_config(
|
||||
omni_config.stage_by_id(stage_id),
|
||||
model="/tmp",
|
||||
)
|
||||
if legacy_stage.stage_type == StageType.DIFFUSION:
|
||||
backend_fields = _DIFFUSION_BACKEND_FIELDS
|
||||
backend_config_cls = OmniDiffusionConfig
|
||||
else:
|
||||
backend_fields = _LLM_BACKEND_FIELDS
|
||||
backend_config_cls = OmniEngineArgs
|
||||
|
||||
missing_fields = (legacy_args.keys() & backend_fields) - typed_args.keys()
|
||||
assert not missing_fields, f"{model_type} stage {stage_id} lost backend fields: {sorted(missing_fields)}"
|
||||
|
||||
legacy_effective_args = _effective_backend_values(backend_config_cls, legacy_args)
|
||||
typed_effective_args = _effective_backend_values(backend_config_cls, typed_args)
|
||||
assert typed_effective_args == legacy_effective_args, (
|
||||
f"{model_type} stage {stage_id} changed effective backend arguments"
|
||||
)
|
||||
Reference in new issue
Block a user