Squashed 'vendor/dumas_h3_continuum/' content from commit d07ed31
git-subtree-dir: vendor/dumas_h3_continuum git-subtree-split: d07ed31b442d283d6a1740f875a843b9feda4c91
This commit is contained in:
@@ -0,0 +1,646 @@
|
||||
"""Observation-only Sampling boundary collector for the V3.8 G4 Gate.
|
||||
|
||||
The collector is loaded only on the dedicated diagnostic backend. It wraps the
|
||||
active Production V3.8 sampler for one node execution, returns the unchanged six
|
||||
Production outputs, and adds a seventh JSON evidence output. Every monkeypatch
|
||||
is restored in ``finally`` blocks.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Mapping, Sequence
|
||||
from dataclasses import asdict, is_dataclass
|
||||
from enum import Enum
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import time
|
||||
from types import SimpleNamespace
|
||||
from typing import Any
|
||||
import uuid
|
||||
|
||||
import torch
|
||||
|
||||
|
||||
CHECKPOINTS = ("S0", "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8")
|
||||
MODEL_CHECKPOINTS = ("M0", "M1", "M2", "M3")
|
||||
|
||||
|
||||
def _type_name(value: Any) -> str:
|
||||
cls = value if isinstance(value, type) else type(value)
|
||||
return f"{cls.__module__}.{cls.__qualname__}"
|
||||
|
||||
|
||||
def _callable_name(value: Any) -> str:
|
||||
return (
|
||||
f"{getattr(value, '__module__', '')}."
|
||||
f"{getattr(value, '__qualname__', type(value).__qualname__)}"
|
||||
)
|
||||
|
||||
|
||||
def _tensor_fingerprint(tensor: torch.Tensor) -> dict[str, Any]:
|
||||
if bool(getattr(tensor, "is_nested", False)):
|
||||
return _nested_fingerprint(tensor)
|
||||
device_before = str(tensor.device)
|
||||
value = tensor.detach().contiguous().to("cpu")
|
||||
shape = [int(part) for part in value.shape]
|
||||
dtype = str(value.dtype)
|
||||
raw = value.view(torch.uint8).numpy().tobytes(order="C")
|
||||
digest = hashlib.sha256()
|
||||
digest.update(dtype.encode("ascii"))
|
||||
digest.update(b"\0")
|
||||
digest.update(json.dumps(shape, separators=(",", ":")).encode("ascii"))
|
||||
digest.update(b"\0")
|
||||
digest.update(raw)
|
||||
legacy_digest = hashlib.sha256()
|
||||
legacy_digest.update(dtype.encode("ascii"))
|
||||
legacy_digest.update(json.dumps(shape, separators=(",", ":")).encode("ascii"))
|
||||
legacy_digest.update(raw)
|
||||
return {
|
||||
"kind": "tensor",
|
||||
"shape": shape,
|
||||
"dtype": dtype,
|
||||
"device_before_hash": device_before,
|
||||
"numel": int(value.numel()),
|
||||
"raw_bytes": len(raw),
|
||||
"sha256": digest.hexdigest(),
|
||||
"legacy_g4_sha256": legacy_digest.hexdigest(),
|
||||
}
|
||||
|
||||
|
||||
def _nested_fingerprint(value: Any) -> dict[str, Any]:
|
||||
parts = list(value.unbind())
|
||||
fingerprints = [_tensor_fingerprint(part) for part in parts]
|
||||
payload = json.dumps(
|
||||
[item["sha256"] for item in fingerprints],
|
||||
separators=(",", ":"),
|
||||
).encode("ascii")
|
||||
return {
|
||||
"kind": "nested_tensor",
|
||||
"parts": fingerprints,
|
||||
"sha256": hashlib.sha256(payload).hexdigest(),
|
||||
}
|
||||
|
||||
|
||||
def _canonicalize(value: Any, unsupported: set[str]) -> Any:
|
||||
if torch.is_tensor(value):
|
||||
fingerprint = _tensor_fingerprint(value)
|
||||
fingerprint.pop("legacy_g4_sha256", None)
|
||||
return {"__tensor__": fingerprint}
|
||||
if hasattr(value, "unbind") and not isinstance(value, (str, bytes)):
|
||||
try:
|
||||
parts = list(value.unbind())
|
||||
except Exception:
|
||||
parts = None
|
||||
if parts is not None and parts and all(torch.is_tensor(part) for part in parts):
|
||||
fingerprint = _nested_fingerprint(value)
|
||||
for part in fingerprint.get("parts", []):
|
||||
part.pop("legacy_g4_sha256", None)
|
||||
return {"__nested_tensor__": fingerprint}
|
||||
if value is None or isinstance(value, (bool, int, float, str)):
|
||||
return value
|
||||
if isinstance(value, bytes):
|
||||
return {
|
||||
"__bytes__": {
|
||||
"length": len(value),
|
||||
"sha256": hashlib.sha256(value).hexdigest(),
|
||||
}
|
||||
}
|
||||
if isinstance(value, (torch.dtype, torch.device, uuid.UUID, Enum)):
|
||||
return {"__type__": _type_name(value), "value": str(value)}
|
||||
if is_dataclass(value) and not isinstance(value, type):
|
||||
return {
|
||||
"__dataclass__": _type_name(value),
|
||||
"value": _canonicalize(asdict(value), unsupported),
|
||||
}
|
||||
if isinstance(value, Mapping):
|
||||
return {
|
||||
str(key): _canonicalize(value[key], unsupported)
|
||||
for key in sorted(value, key=lambda item: str(item))
|
||||
}
|
||||
if isinstance(value, (list, tuple)):
|
||||
return [_canonicalize(item, unsupported) for item in value]
|
||||
if isinstance(value, (set, frozenset)):
|
||||
encoded = [_canonicalize(item, unsupported) for item in value]
|
||||
return sorted(
|
||||
encoded,
|
||||
key=lambda item: json.dumps(item, sort_keys=True, separators=(",", ":")),
|
||||
)
|
||||
if callable(value):
|
||||
return {"__callable__": _callable_name(value)}
|
||||
unsupported.add(_type_name(value))
|
||||
return {"__opaque_type__": _type_name(value)}
|
||||
|
||||
|
||||
def _structured_checkpoint(value: Any) -> dict[str, Any]:
|
||||
unsupported: set[str] = set()
|
||||
canonical = _canonicalize(value, unsupported)
|
||||
encoded = json.dumps(
|
||||
canonical,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
ensure_ascii=False,
|
||||
).encode("utf-8")
|
||||
return {
|
||||
"kind": "structured",
|
||||
"sha256": hashlib.sha256(encoded).hexdigest(),
|
||||
"canonical_bytes": len(encoded),
|
||||
"unsupported_types": sorted(unsupported),
|
||||
"payload": canonical,
|
||||
}
|
||||
|
||||
|
||||
def _value_checkpoint(value: Any) -> dict[str, Any]:
|
||||
if torch.is_tensor(value):
|
||||
return _tensor_fingerprint(value)
|
||||
if hasattr(value, "unbind") and not isinstance(value, (str, bytes)):
|
||||
try:
|
||||
parts = list(value.unbind())
|
||||
except Exception:
|
||||
parts = None
|
||||
if parts is not None and parts and all(torch.is_tensor(part) for part in parts):
|
||||
return _nested_fingerprint(value)
|
||||
return _structured_checkpoint(value)
|
||||
|
||||
|
||||
def _av_checkpoint(value: Any, state_module: Any) -> dict[str, Any]:
|
||||
if isinstance(value, Mapping) and "samples" in value:
|
||||
video, audio = state_module.extract_av_streams(dict(value))
|
||||
else:
|
||||
samples = value
|
||||
parts = list(samples.unbind()) if hasattr(samples, "unbind") else list(samples)
|
||||
if len(parts) < 2:
|
||||
raise RuntimeError("expected MiniMax H3 Video/Audio NestedTensor")
|
||||
video, audio = parts[0], parts[1]
|
||||
streams = {
|
||||
"video": _tensor_fingerprint(video),
|
||||
"audio": _tensor_fingerprint(audio),
|
||||
}
|
||||
combined = json.dumps(
|
||||
{name: item["sha256"] for name, item in streams.items()},
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
).encode("ascii")
|
||||
return {
|
||||
"kind": "h3_av",
|
||||
"streams": streams,
|
||||
"sha256": hashlib.sha256(combined).hexdigest(),
|
||||
}
|
||||
|
||||
|
||||
def _runtime_descriptor(value: Any, depth: int = 0) -> Any:
|
||||
if depth > 7:
|
||||
return {"__truncated_type__": _type_name(value)}
|
||||
if value is None or isinstance(value, (bool, int, float, str)):
|
||||
return value
|
||||
if isinstance(value, (torch.dtype, torch.device, uuid.UUID, Enum)):
|
||||
return {"type": _type_name(value), "value": str(value)}
|
||||
if torch.is_tensor(value):
|
||||
return {
|
||||
"type": "tensor",
|
||||
"shape": [int(part) for part in value.shape],
|
||||
"dtype": str(value.dtype),
|
||||
"device": str(value.device),
|
||||
}
|
||||
if isinstance(value, Mapping):
|
||||
return {
|
||||
str(key): _runtime_descriptor(item, depth + 1)
|
||||
for key, item in sorted(value.items(), key=lambda item: str(item[0]))
|
||||
}
|
||||
if isinstance(value, (list, tuple)):
|
||||
return [_runtime_descriptor(item, depth + 1) for item in value]
|
||||
if isinstance(value, (set, frozenset)):
|
||||
items = [_runtime_descriptor(item, depth + 1) for item in value]
|
||||
return sorted(items, key=lambda item: json.dumps(item, sort_keys=True))
|
||||
if callable(value):
|
||||
return {"callable": _callable_name(value)}
|
||||
return {"type": _type_name(value)}
|
||||
|
||||
|
||||
def _wrapper_state(patcher: Any) -> dict[str, Any]:
|
||||
output: dict[str, Any] = {}
|
||||
for wrapper_type, keyed in sorted(
|
||||
dict(getattr(patcher, "wrappers", {}) or {}).items(),
|
||||
key=lambda item: str(item[0]),
|
||||
):
|
||||
output[str(wrapper_type)] = {
|
||||
str(key): [_callable_name(item) for item in list(items or [])]
|
||||
for key, items in sorted(
|
||||
dict(keyed or {}).items(), key=lambda item: str(item[0])
|
||||
)
|
||||
}
|
||||
return output
|
||||
|
||||
|
||||
def _patch_value_summary(value: Any) -> Any:
|
||||
if isinstance(value, (list, tuple)):
|
||||
return [_patch_value_summary(item) for item in value]
|
||||
if isinstance(value, Mapping):
|
||||
return {
|
||||
str(key): _patch_value_summary(item)
|
||||
for key, item in sorted(value.items(), key=lambda item: str(item[0]))
|
||||
}
|
||||
if callable(value):
|
||||
return {"callable": _callable_name(value)}
|
||||
return {"type": _type_name(value)}
|
||||
|
||||
|
||||
def _model_runtime_state(patcher: Any) -> dict[str, Any]:
|
||||
model = getattr(patcher, "model", None)
|
||||
current_uuid = getattr(model, "current_weight_patches_uuid", None)
|
||||
patches = dict(getattr(patcher, "patches", {}) or {})
|
||||
model_options = dict(getattr(patcher, "model_options", {}) or {})
|
||||
dtype = None
|
||||
try:
|
||||
dtype = str(patcher.model_dtype())
|
||||
except Exception:
|
||||
dtype = None
|
||||
inference_dtype = None
|
||||
try:
|
||||
inference_dtype = str(model.get_dtype_inference()) if model is not None else None
|
||||
except Exception:
|
||||
inference_dtype = None
|
||||
observed = {
|
||||
"patcher_type": _type_name(patcher),
|
||||
"model_type": None if model is None else _type_name(model),
|
||||
"diffusion_model_type": (
|
||||
None
|
||||
if model is None or getattr(model, "diffusion_model", None) is None
|
||||
else _type_name(model.diffusion_model)
|
||||
),
|
||||
"patch_uuid": str(getattr(patcher, "patches_uuid", "")),
|
||||
"current_weight_patch_uuid": (
|
||||
None if current_uuid is None else str(current_uuid)
|
||||
),
|
||||
"load_device": str(getattr(patcher, "load_device", "")),
|
||||
"offload_device": str(getattr(patcher, "offload_device", "")),
|
||||
"model_device": None if model is None else str(getattr(model, "device", "")),
|
||||
"model_dtype": dtype,
|
||||
"inference_dtype": inference_dtype,
|
||||
"hook_mode": str(getattr(patcher, "hook_mode", "")),
|
||||
"current_hook_group_type": (
|
||||
None
|
||||
if getattr(patcher, "current_hook_group", None) is None
|
||||
else _type_name(patcher.current_hook_group)
|
||||
),
|
||||
"wrappers": _wrapper_state(patcher),
|
||||
"patches": {
|
||||
str(key): _patch_value_summary(value)
|
||||
for key, value in sorted(patches.items(), key=lambda item: str(item[0]))
|
||||
},
|
||||
"object_patches": {
|
||||
str(key): _type_name(value)
|
||||
for key, value in sorted(
|
||||
dict(getattr(patcher, "object_patches", {}) or {}).items(),
|
||||
key=lambda item: str(item[0]),
|
||||
)
|
||||
},
|
||||
"model_options": _runtime_descriptor(model_options),
|
||||
"torch": {
|
||||
"deterministic_algorithms": bool(torch.are_deterministic_algorithms_enabled()),
|
||||
"cudnn_deterministic": bool(torch.backends.cudnn.deterministic),
|
||||
"cudnn_benchmark": bool(torch.backends.cudnn.benchmark),
|
||||
"cuda_matmul_allow_tf32": bool(torch.backends.cuda.matmul.allow_tf32),
|
||||
"cudnn_allow_tf32": bool(torch.backends.cudnn.allow_tf32),
|
||||
},
|
||||
}
|
||||
semantic = dict(observed)
|
||||
semantic.pop("patch_uuid", None)
|
||||
semantic.pop("current_weight_patch_uuid", None)
|
||||
semantic["patch_uuid_present"] = bool(observed["patch_uuid"])
|
||||
semantic["current_weight_patch_uuid_present"] = (
|
||||
observed["current_weight_patch_uuid"] is not None
|
||||
)
|
||||
checkpoint = _structured_checkpoint(semantic)
|
||||
checkpoint["observed_state"] = observed
|
||||
return checkpoint
|
||||
|
||||
|
||||
def _sampler_signature(sampler: Any) -> dict[str, Any]:
|
||||
value = {
|
||||
"sampler_type": _type_name(sampler),
|
||||
"sampler_function": (
|
||||
None
|
||||
if getattr(sampler, "sampler_function", None) is None
|
||||
else _callable_name(sampler.sampler_function)
|
||||
),
|
||||
"extra_options": _runtime_descriptor(
|
||||
dict(getattr(sampler, "extra_options", {}) or {})
|
||||
),
|
||||
"inpaint_options": _runtime_descriptor(
|
||||
dict(getattr(sampler, "inpaint_options", {}) or {})
|
||||
),
|
||||
}
|
||||
return _structured_checkpoint(value)
|
||||
|
||||
|
||||
def _resolve_modules() -> SimpleNamespace:
|
||||
import nodes as comfy_nodes
|
||||
|
||||
sampler_class = comfy_nodes.NODE_CLASS_MAPPINGS.get("H3ContinuumSamplerV38")
|
||||
if sampler_class is None:
|
||||
raise RuntimeError("H3ContinuumSamplerV38 is not loaded")
|
||||
owner = sys.modules.get(sampler_class.__module__)
|
||||
source = getattr(owner, "__file__", None)
|
||||
if source is None:
|
||||
raise RuntimeError("cannot resolve active H3 Continuum package")
|
||||
module_name = sampler_class.__module__
|
||||
base_name = (
|
||||
module_name.split(".v3.", 1)[0]
|
||||
if ".v3." in module_name
|
||||
else module_name.rsplit(".", 2)[0]
|
||||
)
|
||||
return SimpleNamespace(
|
||||
sampler_class=sampler_class,
|
||||
production_root=str(Path(source).resolve().parent.parent),
|
||||
sequence=importlib.import_module(f"{base_name}.v2.sequence"),
|
||||
state=importlib.import_module(f"{base_name}.state"),
|
||||
)
|
||||
|
||||
|
||||
class SamplingCollector:
|
||||
def __init__(self, modules: SimpleNamespace, *, trace_steps: bool):
|
||||
self.modules = modules
|
||||
self.trace_steps = bool(trace_steps)
|
||||
self.records: list[dict[str, Any]] = []
|
||||
self.hooks_restored = True
|
||||
|
||||
def _capture_model_payload(
|
||||
self,
|
||||
record: dict[str, Any],
|
||||
*,
|
||||
x: Any,
|
||||
t: Any,
|
||||
c_concat: Any,
|
||||
c_crossattn: Any,
|
||||
control: Any,
|
||||
transformer_options: Any,
|
||||
kwargs: Mapping[str, Any],
|
||||
output: Any,
|
||||
) -> None:
|
||||
record["model"] = {
|
||||
"M0": _value_checkpoint(x),
|
||||
"M1": _value_checkpoint(t),
|
||||
"M2": _structured_checkpoint(
|
||||
{
|
||||
"c_concat": c_concat,
|
||||
"c_crossattn": c_crossattn,
|
||||
"control": control,
|
||||
"transformer_options": transformer_options,
|
||||
"kwargs": dict(kwargs),
|
||||
}
|
||||
),
|
||||
"M3": _value_checkpoint(output),
|
||||
}
|
||||
|
||||
def wrap(self, original_sample):
|
||||
def observed_sample_chunk(**kwargs):
|
||||
import comfy.model_base
|
||||
import comfy.sample
|
||||
import comfy.samplers
|
||||
|
||||
record: dict[str, Any] = {
|
||||
"physical_call_index": len(self.records) + 1,
|
||||
"seed": int(kwargs["seed"]),
|
||||
"checkpoints": {},
|
||||
"model": {},
|
||||
"steps": [],
|
||||
}
|
||||
checkpoints = record["checkpoints"]
|
||||
checkpoints["S0"] = _av_checkpoint(kwargs["latent"], self.modules.state)
|
||||
checkpoints["S3"] = _value_checkpoint(kwargs["latent"].get("noise_mask"))
|
||||
checkpoints["S4"] = _tensor_fingerprint(kwargs["sigmas"])
|
||||
checkpoints["S5"] = _structured_checkpoint(int(kwargs["seed"]))
|
||||
checkpoints["S6"] = _sampler_signature(kwargs["sampler"])
|
||||
checkpoints["S7"] = _structured_checkpoint(kwargs["conditioning"])
|
||||
checkpoints["S8"] = _model_runtime_state(kwargs["model"])
|
||||
|
||||
original_fix = comfy.sample.fix_empty_latent_channels
|
||||
original_noise = comfy.sample.prepare_noise
|
||||
original_apply = comfy.model_base.BaseModel._apply_model
|
||||
original_guider_sample = comfy.samplers.CFGGuider.sample
|
||||
fixed_seen = False
|
||||
noise_seen = False
|
||||
model_seen = False
|
||||
pending_model_payload = None
|
||||
|
||||
def fix_empty(*args, **inner_kwargs):
|
||||
nonlocal fixed_seen
|
||||
result = original_fix(*args, **inner_kwargs)
|
||||
if not fixed_seen:
|
||||
fixed_seen = True
|
||||
checkpoints["S1"] = _av_checkpoint(result, self.modules.state)
|
||||
return result
|
||||
|
||||
def prepare_noise(*args, **inner_kwargs):
|
||||
nonlocal noise_seen
|
||||
result = original_noise(*args, **inner_kwargs)
|
||||
if not noise_seen:
|
||||
noise_seen = True
|
||||
checkpoints["S2"] = _av_checkpoint(result, self.modules.state)
|
||||
return result
|
||||
|
||||
def apply_model(
|
||||
model_self,
|
||||
x,
|
||||
t,
|
||||
c_concat=None,
|
||||
c_crossattn=None,
|
||||
control=None,
|
||||
transformer_options={},
|
||||
**inner_kwargs,
|
||||
):
|
||||
nonlocal model_seen, pending_model_payload
|
||||
result = original_apply(
|
||||
model_self,
|
||||
x,
|
||||
t,
|
||||
c_concat,
|
||||
c_crossattn,
|
||||
control,
|
||||
transformer_options,
|
||||
**inner_kwargs,
|
||||
)
|
||||
if not model_seen and model_self.__class__.__name__ == "MiniMaxH3":
|
||||
model_seen = True
|
||||
# Retain references only. Hashing CUDA tensors here forces a
|
||||
# host synchronization between sampler steps and masks the
|
||||
# ordering defect this Gate is intended to observe.
|
||||
pending_model_payload = {
|
||||
"x": x,
|
||||
"t": t,
|
||||
"c_concat": c_concat,
|
||||
"c_crossattn": c_crossattn,
|
||||
"control": control,
|
||||
"transformer_options": transformer_options,
|
||||
"kwargs": dict(inner_kwargs),
|
||||
"output": result,
|
||||
}
|
||||
return result
|
||||
|
||||
def guider_sample(guider_self, *args, **inner_kwargs):
|
||||
existing_callback = inner_kwargs.get("callback")
|
||||
|
||||
def chained_callback(step, x0, x, total_steps):
|
||||
if existing_callback is not None:
|
||||
existing_callback(step, x0, x, total_steps)
|
||||
record["steps"].append(
|
||||
{
|
||||
"step": int(step),
|
||||
"total_steps": int(total_steps),
|
||||
"x0": _value_checkpoint(x0),
|
||||
"x": _value_checkpoint(x),
|
||||
}
|
||||
)
|
||||
|
||||
if self.trace_steps:
|
||||
inner_kwargs["callback"] = chained_callback
|
||||
record["step_callback_chained"] = existing_callback is not None
|
||||
return original_guider_sample(guider_self, *args, **inner_kwargs)
|
||||
|
||||
comfy.sample.fix_empty_latent_channels = fix_empty
|
||||
comfy.sample.prepare_noise = prepare_noise
|
||||
comfy.model_base.BaseModel._apply_model = apply_model
|
||||
if self.trace_steps:
|
||||
comfy.samplers.CFGGuider.sample = guider_sample
|
||||
started = time.perf_counter()
|
||||
self.records.append(record)
|
||||
try:
|
||||
result = original_sample(**kwargs)
|
||||
if pending_model_payload is not None:
|
||||
self._capture_model_payload(record, **pending_model_payload)
|
||||
record["output"] = _av_checkpoint(result, self.modules.state)
|
||||
record["sampling_elapsed_seconds"] = time.perf_counter() - started
|
||||
record["model_runtime_after"] = _model_runtime_state(kwargs["model"])
|
||||
return result
|
||||
finally:
|
||||
comfy.sample.fix_empty_latent_channels = original_fix
|
||||
comfy.sample.prepare_noise = original_noise
|
||||
comfy.model_base.BaseModel._apply_model = original_apply
|
||||
comfy.samplers.CFGGuider.sample = original_guider_sample
|
||||
restored = (
|
||||
comfy.sample.fix_empty_latent_channels is original_fix
|
||||
and comfy.sample.prepare_noise is original_noise
|
||||
and comfy.model_base.BaseModel._apply_model is original_apply
|
||||
and comfy.samplers.CFGGuider.sample is original_guider_sample
|
||||
)
|
||||
record["hooks_restored"] = bool(restored)
|
||||
record["capture_complete"] = {
|
||||
"fixed_latent": fixed_seen,
|
||||
"noise": noise_seen,
|
||||
"first_model_call": model_seen,
|
||||
"all_sampling_checkpoints": all(
|
||||
name in checkpoints for name in CHECKPOINTS
|
||||
),
|
||||
"all_model_checkpoints": all(
|
||||
name in record["model"] for name in MODEL_CHECKPOINTS
|
||||
),
|
||||
}
|
||||
self.hooks_restored = self.hooks_restored and bool(restored)
|
||||
|
||||
return observed_sample_chunk
|
||||
|
||||
|
||||
class H3G4SamplingDeterminismDiagnostic:
|
||||
RETURN_TYPES = (
|
||||
"LATENT",
|
||||
"LATENT",
|
||||
"H3_CONTINUUM_ASSEMBLY_PLAN",
|
||||
"STRING",
|
||||
"AUDIO",
|
||||
"H3_CONTINUUM_REFINE_CONTEXT",
|
||||
"STRING",
|
||||
)
|
||||
RETURN_NAMES = (
|
||||
"video_latents",
|
||||
"audio_latents",
|
||||
"assembly_plan",
|
||||
"status",
|
||||
"driving_audio",
|
||||
"refine_context",
|
||||
"diagnostic_json",
|
||||
)
|
||||
OUTPUT_IS_LIST = (True, True, False, False, False, False, False)
|
||||
FUNCTION = "run"
|
||||
CATEGORY = "H3 Continuum/Diagnostics"
|
||||
OUTPUT_NODE = True
|
||||
|
||||
@classmethod
|
||||
def INPUT_TYPES(cls):
|
||||
modules = _resolve_modules()
|
||||
schema = modules.sampler_class.INPUT_TYPES()
|
||||
required = dict(schema.get("required", {}))
|
||||
required["diagnostic_label"] = (
|
||||
"STRING",
|
||||
{"default": "sampling_diagnostic"},
|
||||
)
|
||||
required["diagnostic_nonce"] = (
|
||||
"INT",
|
||||
{"default": 0, "min": 0, "max": 0x7FFFFFFF},
|
||||
)
|
||||
required["trace_steps"] = ("BOOLEAN", {"default": False})
|
||||
schema["required"] = required
|
||||
return schema
|
||||
|
||||
@classmethod
|
||||
def IS_CHANGED(cls, generation_mode="Full Run", **kwargs):
|
||||
# Preserve the public V3.8 cache contract exactly: Full Run is stable,
|
||||
# while Review Each Chunk is intentionally non-cacheable.
|
||||
modules = _resolve_modules()
|
||||
return modules.sampler_class.IS_CHANGED(generation_mode=generation_mode)
|
||||
|
||||
def run(
|
||||
self,
|
||||
diagnostic_label,
|
||||
diagnostic_nonce,
|
||||
trace_steps,
|
||||
**kwargs,
|
||||
):
|
||||
modules = _resolve_modules()
|
||||
sequence = modules.sequence
|
||||
collector = SamplingCollector(modules, trace_steps=bool(trace_steps))
|
||||
original_sample = sequence.sample_chunk
|
||||
model = kwargs.get("model")
|
||||
state_before = _model_runtime_state(model)
|
||||
sequence.sample_chunk = collector.wrap(original_sample)
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
outputs = modules.sampler_class().run(**kwargs)
|
||||
state_after = _model_runtime_state(model)
|
||||
finally:
|
||||
sequence.sample_chunk = original_sample
|
||||
restored = sequence.sample_chunk is original_sample and collector.hooks_restored
|
||||
result = {
|
||||
"format": "h3-v38-g4-sampling-determinism-v1",
|
||||
"diagnostic_label": str(diagnostic_label),
|
||||
"diagnostic_nonce": int(diagnostic_nonce),
|
||||
"trace_steps": bool(trace_steps),
|
||||
"production_root": modules.production_root,
|
||||
"sampler_node_elapsed_seconds": time.perf_counter() - started,
|
||||
"sampler_model_state_before": state_before,
|
||||
"sampler_model_state_after": state_after,
|
||||
"physical_samples": collector.records,
|
||||
"physical_sample_count": len(collector.records),
|
||||
"hooks_restored": bool(restored),
|
||||
}
|
||||
payload = json.dumps(
|
||||
result,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
ensure_ascii=False,
|
||||
)
|
||||
return {
|
||||
"ui": {"text": [payload]},
|
||||
"result": (*outputs, payload),
|
||||
}
|
||||
|
||||
|
||||
NODE_CLASS_MAPPINGS = {
|
||||
"H3G4SamplingDeterminismDiagnostic": H3G4SamplingDeterminismDiagnostic,
|
||||
}
|
||||
|
||||
NODE_DISPLAY_NAME_MAPPINGS = {
|
||||
"H3G4SamplingDeterminismDiagnostic": "H3 G4 Sampling Determinism Diagnostic",
|
||||
}
|
||||
Reference in New Issue
Block a user