Release v3.6.1 compatibility hotfix
This commit is contained in:
@@ -0,0 +1,416 @@
|
||||
"""Run the V3.6-R1 three-chunk I2VA Strong Motion Stress Gate."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import copy
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from typing import Any, Mapping
|
||||
|
||||
|
||||
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 submit_and_wait
|
||||
|
||||
|
||||
STRONG_MOTION_PROMPT = (
|
||||
"A dynamic cinematic live-action shot of the woman in the orange jacket "
|
||||
"accelerating rapidly on her skateboard along the waterfront promenade. "
|
||||
"She performs fast continuous S-turns, leaning deeply from side to side "
|
||||
"while her hair and jacket react to speed. The low tracking camera sweeps "
|
||||
"alongside her with a strong continuous pan and partial orbit, maintaining "
|
||||
"motion through the sequence while preserving her face, orange jacket, "
|
||||
"white trousers, skateboard, city skyline, cool daylight, and natural contrast."
|
||||
)
|
||||
|
||||
TRANSPORTS = ("reference_context_v1", "masked_video_prefix_v1")
|
||||
|
||||
|
||||
def _walk_strings(value: Any):
|
||||
if isinstance(value, str):
|
||||
yield value
|
||||
elif isinstance(value, Mapping):
|
||||
for item in value.values():
|
||||
yield from _walk_strings(item)
|
||||
elif isinstance(value, list):
|
||||
for item in value:
|
||||
yield from _walk_strings(item)
|
||||
|
||||
|
||||
def _extract_evidence(history: Mapping[str, Any]) -> dict[str, Any]:
|
||||
lines: list[str] = []
|
||||
diagnostic = None
|
||||
for text in _walk_strings(history):
|
||||
for line in text.splitlines():
|
||||
if line.startswith(("Prompt/CLIP cache [V3.5]", "Performance [V3.5")):
|
||||
lines.append(line)
|
||||
marker = "V3.6-R1 diagnostic: "
|
||||
if marker in line:
|
||||
diagnostic = json.loads(line.split(marker, 1)[1])
|
||||
cache_line = next(
|
||||
(line for line in lines if line.startswith("Prompt/CLIP cache [V3.5]")),
|
||||
None,
|
||||
)
|
||||
cache = None
|
||||
if cache_line:
|
||||
match = re.search(
|
||||
r"hits=(\d+), misses=(\d+), bypasses=(\d+), encode_calls=(\d+)",
|
||||
cache_line,
|
||||
)
|
||||
if match:
|
||||
cache = {
|
||||
"hits": int(match.group(1)),
|
||||
"misses": int(match.group(2)),
|
||||
"bypasses": int(match.group(3)),
|
||||
"encode_calls": int(match.group(4)),
|
||||
}
|
||||
return {
|
||||
"prompt_clip_cache": cache,
|
||||
"performance_lines": lines,
|
||||
"diagnostic": diagnostic,
|
||||
}
|
||||
|
||||
|
||||
class ResourceMonitor:
|
||||
def __init__(self, backend_pid: int | None, interval_seconds: float = 1.0):
|
||||
self.backend_pid = int(backend_pid) if backend_pid else None
|
||||
self.interval_seconds = float(interval_seconds)
|
||||
self.peak_process_rss_bytes = 0
|
||||
self.peak_process_uss_bytes = 0
|
||||
self.minimum_system_available_bytes: int | None = None
|
||||
self.peak_device_used_bytes = 0
|
||||
self.samples = 0
|
||||
self._stop = threading.Event()
|
||||
self._thread: threading.Thread | None = None
|
||||
self._psutil = None
|
||||
self._process = None
|
||||
self._nvml = None
|
||||
self._nvml_handle = None
|
||||
|
||||
def __enter__(self):
|
||||
try:
|
||||
import psutil
|
||||
|
||||
self._psutil = psutil
|
||||
if self.backend_pid:
|
||||
self._process = psutil.Process(self.backend_pid)
|
||||
except Exception:
|
||||
self._psutil = None
|
||||
self._process = None
|
||||
try:
|
||||
import pynvml
|
||||
|
||||
pynvml.nvmlInit()
|
||||
self._nvml = pynvml
|
||||
self._nvml_handle = pynvml.nvmlDeviceGetHandleByIndex(0)
|
||||
except Exception:
|
||||
self._nvml = None
|
||||
self._nvml_handle = None
|
||||
self._sample()
|
||||
self._thread = threading.Thread(target=self._loop, daemon=True)
|
||||
self._thread.start()
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc, tb):
|
||||
self._stop.set()
|
||||
if self._thread is not None:
|
||||
self._thread.join(timeout=max(2.0, self.interval_seconds * 2.0))
|
||||
self._sample()
|
||||
if self._nvml is not None:
|
||||
try:
|
||||
self._nvml.nvmlShutdown()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _loop(self):
|
||||
while not self._stop.wait(self.interval_seconds):
|
||||
self._sample()
|
||||
|
||||
def _sample(self):
|
||||
self.samples += 1
|
||||
if self._psutil is not None:
|
||||
try:
|
||||
available = int(self._psutil.virtual_memory().available)
|
||||
if self.minimum_system_available_bytes is None:
|
||||
self.minimum_system_available_bytes = available
|
||||
else:
|
||||
self.minimum_system_available_bytes = min(
|
||||
self.minimum_system_available_bytes, available
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
if self._process is not None:
|
||||
try:
|
||||
self.peak_process_rss_bytes = max(
|
||||
self.peak_process_rss_bytes,
|
||||
int(self._process.memory_info().rss),
|
||||
)
|
||||
full = self._process.memory_full_info()
|
||||
self.peak_process_uss_bytes = max(
|
||||
self.peak_process_uss_bytes,
|
||||
int(getattr(full, "uss", 0) or 0),
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
if self._nvml is not None and self._nvml_handle is not None:
|
||||
try:
|
||||
used = int(self._nvml.nvmlDeviceGetMemoryInfo(self._nvml_handle).used)
|
||||
self.peak_device_used_bytes = max(self.peak_device_used_bytes, used)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"backend_pid": self.backend_pid,
|
||||
"samples": int(self.samples),
|
||||
"peak_process_rss_bytes": int(self.peak_process_rss_bytes),
|
||||
"peak_process_uss_bytes": int(self.peak_process_uss_bytes),
|
||||
"minimum_system_available_bytes": self.minimum_system_available_bytes,
|
||||
"peak_device_used_bytes": int(self.peak_device_used_bytes),
|
||||
}
|
||||
|
||||
|
||||
def configure_prompt(
|
||||
source: Mapping[str, Any],
|
||||
*,
|
||||
transport: str,
|
||||
output_prefix: str,
|
||||
seed: int,
|
||||
chunks: int,
|
||||
synchronize_sampling: bool,
|
||||
diagnostic_nonce: int,
|
||||
) -> dict[str, Any]:
|
||||
prompt = copy.deepcopy(dict(source))
|
||||
sampler = prompt["305"]
|
||||
sampler["class_type"] = "H3ContinuumMaskedPrefixR1Diagnostic"
|
||||
sampler["_meta"] = {"title": "H3 Continuum V3.6-R1 Stress Diagnostic"}
|
||||
sampler["inputs"].update(
|
||||
{
|
||||
"prompt_mode": "Fixed — one prompt",
|
||||
"chunks": int(chunks),
|
||||
"chunk_seconds": 5.0,
|
||||
"width": 640,
|
||||
"height": 640,
|
||||
"continuity": "Balanced — 22 frames",
|
||||
"base_seed": int(seed),
|
||||
"audio_continuity": False,
|
||||
"diagnostics": "Detailed Report",
|
||||
"show_preview": False,
|
||||
"run_storage": "Off",
|
||||
"continuation_transport": str(transport),
|
||||
"synchronize_sampling": bool(synchronize_sampling),
|
||||
"diagnostic_nonce": int(diagnostic_nonce),
|
||||
}
|
||||
)
|
||||
prompt["188"]["inputs"]["value"] = STRONG_MOTION_PROMPT
|
||||
prompt["306"]["inputs"].update(
|
||||
{
|
||||
"exact_total_duration": True,
|
||||
"audio_seam": "Off",
|
||||
"video_seam": "Off",
|
||||
"buffer_backend": "Auto",
|
||||
"diagnostics": "Detailed Report",
|
||||
}
|
||||
)
|
||||
prompt["191"]["inputs"]["filename_prefix"] = str(output_prefix)
|
||||
return prompt
|
||||
|
||||
|
||||
def _run_one(
|
||||
*,
|
||||
source: Mapping[str, Any],
|
||||
args,
|
||||
label: str,
|
||||
transport: str,
|
||||
seed: int,
|
||||
chunks: int,
|
||||
synchronize_sampling: bool,
|
||||
nonce: int,
|
||||
warmup: bool,
|
||||
) -> dict[str, Any]:
|
||||
run_root = args.output_root / label
|
||||
run_root.mkdir(parents=True, exist_ok=True)
|
||||
output_prefix = f"video/V36_R1_Stress_{label}_seed{seed}"
|
||||
prompt = configure_prompt(
|
||||
source,
|
||||
transport=transport,
|
||||
output_prefix=output_prefix,
|
||||
seed=seed,
|
||||
chunks=chunks,
|
||||
synchronize_sampling=synchronize_sampling,
|
||||
diagnostic_nonce=nonce,
|
||||
)
|
||||
prompt_path = run_root / "prompt.json"
|
||||
prompt_path.write_text(
|
||||
json.dumps(prompt, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
print(
|
||||
f"START label={label} transport={transport} seed={seed} chunks={chunks} "
|
||||
f"sync={synchronize_sampling}",
|
||||
flush=True,
|
||||
)
|
||||
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"v36-r1-stress-{uuid.uuid4().hex}",
|
||||
timeout_seconds=args.timeout_seconds,
|
||||
poll_seconds=args.poll_seconds,
|
||||
)
|
||||
history_path = run_root / "history.json"
|
||||
history_path.write_text(
|
||||
json.dumps(history, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
evidence = _extract_evidence(history)
|
||||
result = {
|
||||
"label": label,
|
||||
"warmup": bool(warmup),
|
||||
"transport": transport,
|
||||
"seed": int(seed),
|
||||
"chunks": int(chunks),
|
||||
"synchronize_sampling": bool(synchronize_sampling),
|
||||
"prompt_id": prompt_id,
|
||||
"api_elapsed_seconds": float(elapsed),
|
||||
"output_prefix": output_prefix,
|
||||
"prompt": str(prompt_path),
|
||||
"history": str(history_path),
|
||||
"resources": monitor.as_dict(),
|
||||
**evidence,
|
||||
}
|
||||
(run_root / "summary.json").write_text(
|
||||
json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
cache = result.get("prompt_clip_cache")
|
||||
if not warmup and (not cache or cache.get("encode_calls") != 0):
|
||||
raise RuntimeError(
|
||||
f"measured run {label} did not use the required Prompt/CLIP cache HIT: {cache}"
|
||||
)
|
||||
diagnostic = result.get("diagnostic") or {}
|
||||
calls = list(diagnostic.get("sample_calls") or [])
|
||||
if transport == "masked_video_prefix_v1" and chunks >= 2:
|
||||
for call in calls[1:]:
|
||||
layouts = list(call.get("packed_layouts") or [])
|
||||
if not layouts:
|
||||
raise RuntimeError(f"masked continuation call has no PackedLayout evidence: {label}")
|
||||
rows = dict(layouts[0].get("rows_by_kind") or {})
|
||||
if int(rows.get("cond", 0)) != 0 or int(rows.get("ref_img", 0)) != 0:
|
||||
raise RuntimeError(
|
||||
f"masked continuation retained unfair I2VA/reference rows in {label}: {rows}"
|
||||
)
|
||||
final_pairs = list(diagnostic.get("final_prefix_pairs") or [])
|
||||
if len(final_pairs) != chunks - 1 or not all(
|
||||
bool(item.get("bit_exact")) for item in final_pairs
|
||||
):
|
||||
raise RuntimeError(
|
||||
f"masked final prefix contract failed in {label}: {final_pairs}"
|
||||
)
|
||||
print(
|
||||
f"DONE label={label} elapsed={elapsed:.3f}s cache={cache} "
|
||||
f"rss={monitor.peak_process_rss_bytes / 2**30:.3f}GiB",
|
||||
flush=True,
|
||||
)
|
||||
return result
|
||||
|
||||
|
||||
def run(args) -> dict[str, Any]:
|
||||
source = json.loads(args.prompt.read_text(encoding="utf-8"))
|
||||
args.output_root.mkdir(parents=True, exist_ok=True)
|
||||
seeds = [int(args.seed) + index for index in range(3)]
|
||||
if args.mode == "normal":
|
||||
schedule = [
|
||||
(seeds[0], "reference_context_v1"),
|
||||
(seeds[0], "masked_video_prefix_v1"),
|
||||
(seeds[1], "masked_video_prefix_v1"),
|
||||
(seeds[1], "reference_context_v1"),
|
||||
(seeds[2], "reference_context_v1"),
|
||||
(seeds[2], "masked_video_prefix_v1"),
|
||||
]
|
||||
else:
|
||||
schedule = [
|
||||
(seeds[0], "reference_context_v1"),
|
||||
(seeds[0], "masked_video_prefix_v1"),
|
||||
]
|
||||
|
||||
results = []
|
||||
nonce = int(time.time()) & 0x7FFFFFFF
|
||||
if not args.skip_warmup:
|
||||
results.append(
|
||||
_run_one(
|
||||
source=source,
|
||||
args=args,
|
||||
label=f"warmup_{args.mode}",
|
||||
transport="masked_video_prefix_v1",
|
||||
seed=seeds[0],
|
||||
chunks=int(args.warmup_chunks),
|
||||
synchronize_sampling=False,
|
||||
nonce=nonce,
|
||||
warmup=True,
|
||||
)
|
||||
)
|
||||
nonce += 1
|
||||
|
||||
for index, (seed, transport) in enumerate(schedule, start=1):
|
||||
short = "reference" if transport.startswith("reference") else "masked"
|
||||
label = f"{args.mode}_{index:02d}_seed{seed}_{short}"
|
||||
results.append(
|
||||
_run_one(
|
||||
source=source,
|
||||
args=args,
|
||||
label=label,
|
||||
transport=transport,
|
||||
seed=seed,
|
||||
chunks=3,
|
||||
synchronize_sampling=args.mode == "sync",
|
||||
nonce=nonce,
|
||||
warmup=False,
|
||||
)
|
||||
)
|
||||
nonce += 1
|
||||
|
||||
summary = {
|
||||
"format": "h3-continuum-v36-r1-stress-gate-v1",
|
||||
"mode": args.mode,
|
||||
"server": args.server,
|
||||
"base_seed": int(args.seed),
|
||||
"warmup_excluded": True,
|
||||
"pinned_memory_required_disabled": True,
|
||||
"runs": results,
|
||||
}
|
||||
(args.output_root / "stress_gate_summary.json").write_text(
|
||||
json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8"
|
||||
)
|
||||
return summary
|
||||
|
||||
|
||||
def _parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--server", default="http://127.0.0.1:8188")
|
||||
parser.add_argument("--prompt", type=Path, required=True)
|
||||
parser.add_argument("--output-root", type=Path, required=True)
|
||||
parser.add_argument("--mode", choices=("normal", "sync"), default="normal")
|
||||
parser.add_argument("--seed", type=int, default=238985343135601)
|
||||
parser.add_argument("--backend-pid", type=int)
|
||||
parser.add_argument("--timeout-seconds", type=float, default=2400.0)
|
||||
parser.add_argument("--poll-seconds", type=float, default=2.0)
|
||||
parser.add_argument("--monitor-interval", type=float, default=1.0)
|
||||
parser.add_argument("--skip-warmup", action="store_true")
|
||||
parser.add_argument("--warmup-chunks", type=int, choices=(1, 2), default=1)
|
||||
return parser
|
||||
|
||||
|
||||
def main() -> int:
|
||||
args = _parser().parse_args()
|
||||
print(json.dumps(run(args), ensure_ascii=False))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user