Files
sglang/docs/scripts/tests/wan-animate-2-config.test.mjs

198 lines
11 KiB
JavaScript

import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import test from "node:test";
const source = readFileSync(new URL("../../src/snippets/configs/Wan/wan-animate-2.jsx", import.meta.url), "utf8");
const { config } = await import("data:text/javascript," + encodeURIComponent(source));
const selection = (overrides = {}) => ({
...config.commandBuilder.defaultSelection,
...Object.fromEntries(config.overlayDims.map((dim) => [dim.id, dim.default])),
...overrides,
});
const resolve = (overrides = {}) => config.commandBuilder.resolveDeployment(selection(overrides));
// Independent expectations from the legacy picker's seven deployment presets.
const presets = [
["single", 1, "off", 1, 1, []],
["cfg2", 2, "on", 1, 1, ["--enable-cfg-parallel"]],
["sp2", 2, "off", 1, 2, ["--ulysses-degree 2"]],
["tp2", 2, "off", 2, 1, ["--tp-size 2"]],
["cfg-sp4", 4, "on", 1, 2, ["--enable-cfg-parallel", "--ulysses-degree 2"]],
["tp-sp4", 4, "off", 2, 2, ["--tp-size 2", "--ulysses-degree 2"]],
["cfg-tp-sp8", 8, "on", 2, 2, ["--enable-cfg-parallel", "--tp-size 2", "--ulysses-degree 2"]],
];
const placementFlags = {
auto: [],
speed: ["--performance-mode speed"],
memory: ["--performance-mode memory"],
offload: ["--dit-layerwise-offload", "--layerwise-offload-components transformer"],
"cfg-regression": ["--dit-layerwise-offload", "--layerwise-offload-components transformer",
"--encoder-parallel replicate", "--vae-config.use-parallel-decode false"],
};
test("all 233 legacy selections preserve flags, environment and verification", () => {
let combinations = 0;
let verified = 0;
for (const hw of ["h200", "b300", "rtx4090", "gb200", "h100"]) {
for (const [preset, gpus_per_node, cfg, tp_size, ulysses_degree, flags] of presets) {
for (const placement of Object.keys(placementFlags)) {
for (const encoder of ["auto", "offload"]) {
if (placement === "cfg-regression" && preset !== "cfg2") continue;
if (hw === "rtx4090" && (preset !== "single" || placement !== "memory" || encoder !== "auto")) continue;
const s = { hw, gpus_per_node, cfg, tp_size, ulysses_degree, placement, encoder, topology_mode: "manual" };
const result = resolve(s);
const expectedFlags = ["--model-path {{MODEL_NAME}}", "--port {{PORT}}", `--num-gpus ${gpus_per_node}`,
...flags, ...placementFlags[placement], ...(encoder === "offload" ? ["--text-encoder-cpu-offload"] : [])];
const expectedEnv = hw === "rtx4090" ? ["PYTORCH_ALLOC_CONF=expandable_segments:True"]
: placement === "cfg-regression" ? ["SGLANG_DIFFUSION_VAE_CHANNELS_LAST_3D=1"] : [];
const isVerified = encoder === "auto" && (
(["h200", "b300"].includes(hw) && preset === "single" && ["auto", "memory"].includes(placement))
|| (hw === "b300" && preset === "cfg2" && ["auto", "cfg-regression"].includes(placement))
|| hw === "rtx4090"
);
const label = JSON.stringify(s);
assert.deepEqual(result.builder.errors, [], label);
assert.deepEqual([...result.flags].sort(), expectedFlags.sort(), label);
assert.deepEqual(result.env, expectedEnv, label);
assert.equal(result.verified, isVerified, label);
assert.deepEqual(result.builder.verification, {
serve: isVerified ? "verified" : "unverified",
request: isVerified ? "verified" : "unverified",
}, label);
combinations++;
verified += Number(isVerified);
}
}
}
}
assert.equal(combinations, 233);
assert.equal(verified, 7);
});
test("H3 builder uses scoped settings and preserves the default HTTP workload", () => {
assert.equal(config.cells, undefined);
assert.deepEqual(config.overlayDims.filter((d) => d.scope === "base").map((d) => d.id), ["weights"]);
assert.deepEqual(config.overlayDims.filter((d) => d.scope === "serve").map((d) => d.id), ["placement", "encoder", "cfg"]);
assert.deepEqual(config.overlayDims.filter((d) => d.scope === "request").map((d) => d.id), ["resolution", "clip_len", "steps", "distilled_steps", "audio"]);
assert.equal(config.overlayDims.find((d) => d.id === "steps").unit, "steps");
assert.equal(config.curl(selection()), [
"curl -sS -X POST http://{{CURL_HOST}}:{{CURL_PORT}}/v1/videos",
'--form-string "prompt=a person dancing"',
'--form-string "video_path={{INPUT_VIDEO}}"',
'--form-string "clip_len=37"',
'--form-string "size=640x800"',
'--form-string "num_inference_steps=40"',
'--form-string "guidance_scale=3.0"',
'--form-string "fps=16"',
'--form-string "seed=42"',
'--form-string "enable_audio=false"',
'--form "input_reference=@{{INPUT_IMAGE}};type=image/png"',
].join(" \\\n "));
});
test("recommended recipes have accurate verification and consumer memory settings", () => {
const recipes = config.commandBuilder.resource.verifiedRecipes;
assert.equal(recipes.filter((r) => !r.unverified && r.weights !== "distilled").length, 7);
assert.equal(recipes.filter((r) => r.weights === "distilled").length, 9);
for (const hw of config.supportedHardware) {
assert.equal(recipes.filter((r) => r.hw === hw && r.default).length, 1);
}
for (const recipe of recipes) {
const result = resolve({ ...recipe, topology_mode: "manual" });
assert.deepEqual(result.builder.errors, []);
assert.equal(result.verified, !recipe.unverified);
}
const consumer = resolve({ hw: "rtx4090" });
assert.ok(consumer.flags.includes("--performance-mode memory"));
assert.deepEqual(consumer.env, ["PYTORCH_ALLOC_CONF=expandable_segments:True"]);
assert.equal(consumer.verified, true);
assert.equal(resolve({ hw: "h100", placement: "offload" }).verified, false);
assert.equal(resolve({ hw: "gb200" }).verified, false);
});
test("request changes affect only the payload and request verification", () => {
const baseline = resolve();
for (const [overrides, expected] of [
[{ steps: 20 }, "num_inference_steps=20"],
[{ clip_len: "65" }, "clip_len=65"],
[{ resolution: "720x1280" }, "size=720x1280"],
[{ audio: "true" }, "enable_audio=true"],
]) {
const result = resolve(overrides);
assert.deepEqual(result.flags, baseline.flags);
assert.deepEqual(result.env, baseline.env);
assert.deepEqual(result.builder.verification, { serve: "verified", request: "unverified" });
assert.ok(config.curl(selection(overrides)).includes(expected));
}
});
test("automatic topology accounts for CFG ranks", () => {
for (const [gpus_per_node, cfg, tp, ulysses] of [
[1, "auto", 1, 1], [2, "auto", 1, 1], [4, "auto", 1, 2], [8, "auto", 2, 2],
[2, "off", 1, 2], [4, "off", 2, 2],
]) {
const result = resolve({ gpus_per_node, cfg });
assert.deepEqual(result.builder.errors, []);
assert.deepEqual(result.builder.topology, { tp_size: tp, ulysses_degree: ulysses, ring_degree: 1 });
}
assert.equal(resolve({ gpus_per_node: 4 }).builder.verification.serve, "unverified");
});
test("invalid resource and topology combinations cannot be verified", () => {
for (const overrides of [
{ nodes: 2 }, { gpus_per_node: 0 }, { gpus_per_node: 9 }, { gpus_per_node: 1.5 },
{ cfg: "on" }, { gpus_per_node: 3, cfg: "on" }, { gpus_per_node: 6, cfg: "off" },
{ topology_mode: "manual", tp_size: 0 },
{ topology_mode: "manual", gpus_per_node: 2, cfg: "off" },
{ topology_mode: "manual", gpus_per_node: 2, cfg: "off", ring_degree: 2 },
{ placement: "cfg-regression" },
{ placement: "cfg-regression", gpus_per_node: 2, cfg: "off" },
{ hw: "rtx4090", placement: "speed" }, { hw: "rtx4090", encoder: "offload" },
]) {
const result = resolve(overrides);
assert.ok(result.builder.errors.length, JSON.stringify(overrides));
assert.equal(result.verified, false);
assert.deepEqual(result.builder.verification, { serve: "error", request: "error" });
}
});
test("distilled checkpoint: GB200 recipes, Ulysses auto topology and no CFG parallelism", () => {
const recipes = config.commandBuilder.resource.verifiedRecipes.filter((r) => r.weights === "distilled");
for (const recipe of recipes) {
assert.equal(recipe.hw, "gb200");
const result = resolve({ ...recipe, topology_mode: "manual" });
assert.deepEqual(result.builder.errors, [], recipe.id);
assert.equal(result.verified, true, recipe.id);
assert.deepEqual(result.builder.verification, { serve: "verified", request: "verified" }, recipe.id);
assert.ok(result.flags.includes("--model-path {{DISTILLED_MODEL_PATH}}"), recipe.id);
assert.ok(result.flags.includes("--text-encoder-cpu-offload"), recipe.id);
assert.ok(!result.flags.includes("--enable-cfg-parallel"), recipe.id);
assert.deepEqual(result.env, [], recipe.id);
}
// Auto topology is Ulysses across the GPUs; explicit CPU offload is the same command.
const four = resolve({ weights: "distilled", hw: "gb200", gpus_per_node: 4 });
assert.deepEqual(four.builder.topology, { tp_size: 1, ulysses_degree: 4, ring_degree: 1 });
assert.deepEqual(four.flags, ["--model-path {{DISTILLED_MODEL_PATH}}", "--port {{PORT}}", "--num-gpus 4",
"--ulysses-degree 4", "--text-encoder-cpu-offload"]);
assert.equal(four.verified, true);
assert.deepEqual(resolve({ weights: "distilled", hw: "gb200", encoder: "offload" }).flags,
resolve({ weights: "distilled", hw: "gb200" }).flags);
assert.equal(resolve({ weights: "distilled", hw: "gb200", encoder: "offload" }).verified, true);
assert.equal(resolve({ weights: "distilled", hw: "gb200", gpus_per_node: 2 }).builder.topology.ulysses_degree, 2);
assert.equal(resolve({ weights: "distilled", hw: "gb200" }).builder.resolvedSettings.cfg, "Disabled");
// The request carries the distilled defaults; a step change leaves the verified serve recipe alone.
const request = config.curl(selection({ weights: "distilled" }));
assert.ok(request.includes("num_inference_steps=10"));
assert.ok(request.includes("guidance_scale=1.0"));
const steps = resolve({ weights: "distilled", hw: "gb200", distilled_steps: 20 });
assert.deepEqual(steps.builder.verification, { serve: "verified", request: "unverified" });
assert.ok(config.curl(selection({ weights: "distilled", distilled_steps: 20 })).includes("num_inference_steps=20"));
// Other hardware is unverified, CFG parallelism is rejected, and the base checkpoint keeps GB200 derived.
assert.equal(resolve({ weights: "distilled", hw: "h200" }).verified, false);
const cfgOn = resolve({ weights: "distilled", hw: "gb200", gpus_per_node: 2, cfg: "on" });
assert.ok(cfgOn.builder.errors.length);
assert.deepEqual(cfgOn.builder.verification, { serve: "error", request: "error" });
assert.equal(resolve({ hw: "gb200" }).verified, false);
assert.equal(resolve({ hw: "gb200" }).builder.verification.serve, "unverified");
});