Release V3.8 source, illustrated manual and Spectrum workflow
This commit is contained in:
@@ -0,0 +1,430 @@
|
||||
"""Run the three-case V3.8 main-sampler resolution GPU mini Gate."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import copy
|
||||
from dataclasses import asdict, dataclass
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
from typing import Any, Mapping
|
||||
import uuid
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
TOOLS_ROOT = Path(__file__).resolve().parent
|
||||
if str(TOOLS_ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(TOOLS_ROOT))
|
||||
|
||||
from p32_api_runner import _json_request, submit_and_wait
|
||||
from v36_r1_stress_gate_runner import ResourceMonitor
|
||||
from v38_easy_gpu_gate_runner import _output_media, _probe_media
|
||||
|
||||
|
||||
class GateFailure(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GateCase:
|
||||
name: str
|
||||
aspect: str
|
||||
preset: str
|
||||
custom_mp: float
|
||||
first_image: bool
|
||||
expected_width: int
|
||||
expected_height: int
|
||||
prompt: str
|
||||
|
||||
|
||||
CASES = (
|
||||
GateCase(
|
||||
name="g1_draft_landscape",
|
||||
aspect="Landscape 16:9",
|
||||
preset="Draft — 0.30 MP",
|
||||
custom_mp=0.30,
|
||||
first_image=False,
|
||||
expected_width=736,
|
||||
expected_height=416,
|
||||
prompt=(
|
||||
"A continuous cinematic landscape shot tracks a woman walking across "
|
||||
"a modern plaza. Natural body motion, stable lighting, footsteps, wind, "
|
||||
"and distant city ambience continue without a cut."
|
||||
),
|
||||
),
|
||||
GateCase(
|
||||
name="g2_balanced_portrait",
|
||||
aspect="Portrait 9:16",
|
||||
preset="Balanced — 0.60 MP",
|
||||
custom_mp=0.30,
|
||||
first_image=False,
|
||||
expected_width=576,
|
||||
expected_height=1024,
|
||||
prompt=(
|
||||
"A continuous portrait-format cinematic shot follows a woman walking "
|
||||
"toward camera through a city street. Preserve coherent anatomy, natural "
|
||||
"motion, stable exposure, footsteps, and urban ambience."
|
||||
),
|
||||
),
|
||||
GateCase(
|
||||
name="g3_native_auto_first_image",
|
||||
aspect="Auto from First Image",
|
||||
preset="Native 768",
|
||||
custom_mp=0.30,
|
||||
first_image=True,
|
||||
expected_width=768,
|
||||
expected_height=1024,
|
||||
prompt=(
|
||||
"A continuous cinematic shot begins from the supplied First Image. The "
|
||||
"subject moves naturally while identity, clothing, lighting, camera "
|
||||
"direction, footsteps, and ambience remain coherent."
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def _sha256(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as stream:
|
||||
for block in iter(lambda: stream.read(1024 * 1024), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def _resolve_origin(
|
||||
node_id: str,
|
||||
output_slot: int,
|
||||
*,
|
||||
nodes: Mapping[str, Mapping[str, Any]],
|
||||
links: Mapping[str, list[Any]],
|
||||
seen: set[tuple[str, int]] | None = None,
|
||||
) -> list[Any] | None:
|
||||
seen = set(seen or ())
|
||||
key = (str(node_id), int(output_slot))
|
||||
if key in seen:
|
||||
return None
|
||||
seen.add(key)
|
||||
node = nodes.get(str(node_id))
|
||||
if not isinstance(node, Mapping):
|
||||
return None
|
||||
mode = int(node.get("mode", 0) or 0)
|
||||
if mode == 0:
|
||||
return [str(node_id), int(output_slot)]
|
||||
if mode != 4:
|
||||
return None
|
||||
outputs = list(node.get("outputs") or [])
|
||||
output_type = outputs[output_slot].get("type") if output_slot < len(outputs) else None
|
||||
candidates = []
|
||||
for input_value in node.get("inputs") or []:
|
||||
link_id = input_value.get("link")
|
||||
input_type = input_value.get("type")
|
||||
if link_id is None:
|
||||
continue
|
||||
if output_type not in (None, "*") and input_type not in (output_type, "*"):
|
||||
continue
|
||||
candidates.append(str(link_id))
|
||||
if len(candidates) != 1:
|
||||
return None
|
||||
link = links.get(candidates[0])
|
||||
if not link:
|
||||
return None
|
||||
return _resolve_origin(
|
||||
str(link[1]),
|
||||
int(link[2]),
|
||||
nodes=nodes,
|
||||
links=links,
|
||||
seen=seen,
|
||||
)
|
||||
|
||||
|
||||
def _build_prompt(
|
||||
workflow: Mapping[str, Any],
|
||||
object_info: Mapping[str, Any],
|
||||
*,
|
||||
case: GateCase,
|
||||
image_name: str,
|
||||
output_prefix: str,
|
||||
seed: int,
|
||||
) -> dict[str, Any]:
|
||||
nodes = {str(node["id"]): copy.deepcopy(node) for node in workflow["nodes"]}
|
||||
links = {str(link[0]): list(link) for link in workflow["links"]}
|
||||
sampler_ids = [node_id for node_id, node in nodes.items() if node["type"] == "H3ContinuumSamplerV37"]
|
||||
if len(sampler_ids) != 1:
|
||||
raise GateFailure(f"expected one V3.7 source sampler, found {len(sampler_ids)}")
|
||||
sampler_id = sampler_ids[0]
|
||||
nodes[sampler_id]["type"] = "H3ContinuumSamplerV38"
|
||||
nodes[sampler_id].setdefault("properties", {})["Node name for S&R"] = (
|
||||
"H3ContinuumSamplerV38"
|
||||
)
|
||||
sampler_named = dict(nodes[sampler_id].get("widgets_values_named") or {})
|
||||
sampler_named.pop("width", None)
|
||||
sampler_named.pop("height", None)
|
||||
sampler_named.update(
|
||||
{
|
||||
"aspect": case.aspect,
|
||||
"preset": case.preset,
|
||||
"custom_mp": case.custom_mp,
|
||||
"chunks": 1,
|
||||
"chunk_seconds": 5.0,
|
||||
"base_seed": int(seed),
|
||||
"diagnostics": "Detailed Report",
|
||||
"show_preview": False,
|
||||
"run_storage": "Off",
|
||||
"run_name": "",
|
||||
"project_id": f"v38-resolution-{case.name}-{seed}",
|
||||
}
|
||||
)
|
||||
nodes[sampler_id]["widgets_values_named"] = sampler_named
|
||||
|
||||
for node in nodes.values():
|
||||
if node["type"] == "PrimitiveStringMultiline":
|
||||
node.setdefault("widgets_values_named", {})["value"] = case.prompt
|
||||
elif node["type"] == "LoadImage" and int(node["id"]) == 114:
|
||||
node.setdefault("widgets_values_named", {})["image"] = image_name
|
||||
elif node["type"] == "SaveVideo":
|
||||
node.setdefault("widgets_values_named", {})["filename_prefix"] = output_prefix
|
||||
|
||||
prompt: dict[str, Any] = {}
|
||||
|
||||
def add_node(node_id: str) -> None:
|
||||
if node_id in prompt:
|
||||
return
|
||||
node = nodes[node_id]
|
||||
if int(node.get("mode", 0) or 0) != 0:
|
||||
return
|
||||
class_type = str(node["type"])
|
||||
info = object_info.get(class_type)
|
||||
if not isinstance(info, Mapping):
|
||||
raise GateFailure(f"object_info has no node class {class_type}")
|
||||
valid_inputs = set()
|
||||
input_schema = info.get("input") or {}
|
||||
valid_inputs.update((input_schema.get("required") or {}).keys())
|
||||
valid_inputs.update((input_schema.get("optional") or {}).keys())
|
||||
api_inputs: dict[str, Any] = {}
|
||||
for input_value in node.get("inputs") or []:
|
||||
name = str(input_value.get("name"))
|
||||
if name in {"width", "height"}:
|
||||
continue
|
||||
if node_id == sampler_id and name == "first_frame" and not case.first_image:
|
||||
continue
|
||||
link_id = input_value.get("link")
|
||||
if link_id is None or name not in valid_inputs:
|
||||
continue
|
||||
link = links.get(str(link_id))
|
||||
if not link:
|
||||
continue
|
||||
origin = _resolve_origin(
|
||||
str(link[1]),
|
||||
int(link[2]),
|
||||
nodes=nodes,
|
||||
links=links,
|
||||
)
|
||||
if origin is None:
|
||||
continue
|
||||
api_inputs[name] = origin
|
||||
add_node(str(origin[0]))
|
||||
for name, value in (node.get("widgets_values_named") or {}).items():
|
||||
if name in valid_inputs and name not in api_inputs:
|
||||
api_inputs[str(name)] = value
|
||||
prompt[node_id] = {
|
||||
"class_type": class_type,
|
||||
"inputs": api_inputs,
|
||||
"_meta": {"title": str(node.get("title") or class_type)},
|
||||
}
|
||||
|
||||
output_ids = [
|
||||
node_id
|
||||
for node_id, node in nodes.items()
|
||||
if node["type"] == "SaveVideo" and int(node.get("mode", 0) or 0) == 0
|
||||
]
|
||||
if len(output_ids) != 1:
|
||||
raise GateFailure(f"expected one active SaveVideo, found {len(output_ids)}")
|
||||
add_node(output_ids[0])
|
||||
if sampler_id not in prompt:
|
||||
raise GateFailure("V3.8 sampler is not connected to the SaveVideo output")
|
||||
return prompt
|
||||
|
||||
|
||||
def _media_health(path: Path, ffmpeg: str) -> dict[str, Any]:
|
||||
video_result = subprocess.run(
|
||||
[
|
||||
ffmpeg,
|
||||
"-v",
|
||||
"error",
|
||||
"-i",
|
||||
str(path),
|
||||
"-vf",
|
||||
"fps=1,scale=64:64",
|
||||
"-pix_fmt",
|
||||
"rgb24",
|
||||
"-f",
|
||||
"rawvideo",
|
||||
"-",
|
||||
],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
)
|
||||
frame_size = 64 * 64 * 3
|
||||
frame_count = len(video_result.stdout) // frame_size
|
||||
frames = np.frombuffer(video_result.stdout[: frame_count * frame_size], dtype=np.uint8)
|
||||
frames = frames.reshape(frame_count, 64, 64, 3)
|
||||
frame_means = frames.mean(axis=(1, 2, 3))
|
||||
video_std = float(frames.astype(np.float32).std())
|
||||
|
||||
audio_result = subprocess.run(
|
||||
[
|
||||
ffmpeg,
|
||||
"-v",
|
||||
"error",
|
||||
"-i",
|
||||
str(path),
|
||||
"-map",
|
||||
"0:a:0",
|
||||
"-f",
|
||||
"f32le",
|
||||
"-acodec",
|
||||
"pcm_f32le",
|
||||
"-",
|
||||
],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
)
|
||||
audio = np.frombuffer(audio_result.stdout, dtype=np.float32)
|
||||
return {
|
||||
"sampled_video_frames": int(frame_count),
|
||||
"video_mean": float(frames.mean()),
|
||||
"video_std": video_std,
|
||||
"black_sample_fraction": float(np.mean(frame_means < 2.0)),
|
||||
"video_not_black_or_collapsed": bool(
|
||||
frame_count > 0 and video_std > 2.0 and np.any(frame_means >= 2.0)
|
||||
),
|
||||
"audio_samples": int(audio.size),
|
||||
"audio_finite": bool(audio.size > 0 and np.isfinite(audio).all()),
|
||||
"audio_peak": float(np.max(np.abs(audio))) if audio.size else 0.0,
|
||||
}
|
||||
|
||||
|
||||
def run(args) -> dict[str, Any]:
|
||||
workflow = json.loads(args.workflow.read_text(encoding="utf-8"))
|
||||
object_info = _json_request(f"{args.server.rstrip('/')}/object_info")
|
||||
if "H3ContinuumSamplerV38" not in object_info:
|
||||
raise GateFailure("runtime has no H3ContinuumSamplerV38")
|
||||
ffmpeg = shutil.which("ffmpeg")
|
||||
ffprobe = shutil.which("ffprobe")
|
||||
if not ffmpeg or not ffprobe:
|
||||
raise GateFailure("ffmpeg and ffprobe are required")
|
||||
args.output_root.mkdir(parents=True, exist_ok=True)
|
||||
results = []
|
||||
for index, case in enumerate(CASES, start=1):
|
||||
case_root = args.output_root / case.name
|
||||
case_root.mkdir(parents=True, exist_ok=True)
|
||||
prompt = _build_prompt(
|
||||
workflow,
|
||||
object_info,
|
||||
case=case,
|
||||
image_name=args.image_name,
|
||||
output_prefix=f"v38_resolution_gate/{case.name}",
|
||||
seed=args.seed,
|
||||
)
|
||||
prompt_path = case_root / "prompt.json"
|
||||
prompt_path.write_text(
|
||||
json.dumps(prompt, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
print(
|
||||
f"V3.8 Resolution Gate start {index}/{len(CASES)} {case.name}",
|
||||
flush=True,
|
||||
)
|
||||
if args.dry_run:
|
||||
results.append({"case": asdict(case), "prompt": str(prompt_path)})
|
||||
continue
|
||||
with ResourceMonitor(args.backend_pid, args.monitor_interval) as monitor:
|
||||
prompt_id, history, elapsed = submit_and_wait(
|
||||
server=args.server,
|
||||
prompt=prompt,
|
||||
client_id=f"v38-resolution-{uuid.uuid4().hex}",
|
||||
timeout_seconds=args.timeout_seconds,
|
||||
poll_seconds=args.poll_seconds,
|
||||
)
|
||||
history_path = case_root / "history.json"
|
||||
history_path.write_text(
|
||||
json.dumps(history, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
media_path = _output_media(history, args.media_root)
|
||||
media = _probe_media(media_path, ffprobe)
|
||||
health = _media_health(media_path, ffmpeg)
|
||||
checks = {
|
||||
"geometry": (media["width"], media["height"])
|
||||
== (case.expected_width, case.expected_height),
|
||||
"frames": int(media["frames"]) == 120,
|
||||
"fps": str(media["fps"]) == "24/1",
|
||||
"duration": abs(float(media["format_duration"]) - 5.0) <= 0.02,
|
||||
"audio_rate": int(media["audio_sample_rate"]) == 32000,
|
||||
"audio_channels": int(media["audio_channels"]) == 2,
|
||||
"audio_finite": bool(health["audio_finite"]),
|
||||
"video_not_black_or_collapsed": bool(
|
||||
health["video_not_black_or_collapsed"]
|
||||
),
|
||||
}
|
||||
if not all(checks.values()):
|
||||
raise GateFailure(f"{case.name} failed: {checks}")
|
||||
result = {
|
||||
"case": asdict(case),
|
||||
"prompt_id": prompt_id,
|
||||
"api_elapsed_seconds": float(elapsed),
|
||||
"prompt": str(prompt_path),
|
||||
"history": str(history_path),
|
||||
"media": media,
|
||||
"health": health,
|
||||
"resource": monitor.as_dict(),
|
||||
"checks": checks,
|
||||
}
|
||||
results.append(result)
|
||||
print(
|
||||
f"V3.8 Resolution Gate PASS {case.name} "
|
||||
f"{media['width']}x{media['height']} {elapsed:.3f}s",
|
||||
flush=True,
|
||||
)
|
||||
summary = {
|
||||
"format": "h3-continuum-v38-main-resolution-gpu-gate-v1",
|
||||
"server": args.server,
|
||||
"backend_pid": args.backend_pid,
|
||||
"workflow": str(args.workflow),
|
||||
"workflow_sha256": _sha256(args.workflow),
|
||||
"image_name": args.image_name,
|
||||
"seed": args.seed,
|
||||
"dry_run": bool(args.dry_run),
|
||||
"pass": bool(not args.dry_run and len(results) == len(CASES)),
|
||||
"results": results,
|
||||
}
|
||||
(args.output_root / "gate_summary.json").write_text(
|
||||
json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
return summary
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--server", default="http://127.0.0.6:8190")
|
||||
parser.add_argument("--workflow", type=Path, required=True)
|
||||
parser.add_argument("--output-root", type=Path, required=True)
|
||||
parser.add_argument("--media-root", type=Path, required=True)
|
||||
parser.add_argument("--image-name", required=True)
|
||||
parser.add_argument("--backend-pid", type=int, default=None)
|
||||
parser.add_argument("--seed", type=int, default=927966463230733)
|
||||
parser.add_argument("--timeout-seconds", type=float, default=1200.0)
|
||||
parser.add_argument("--poll-seconds", type=float, default=2.0)
|
||||
parser.add_argument("--monitor-interval", type=float, default=1.0)
|
||||
parser.add_argument("--dry-run", action="store_true")
|
||||
args = parser.parse_args()
|
||||
summary = run(args)
|
||||
print(json.dumps(summary, indent=2, ensure_ascii=False), flush=True)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user