Files
DumasNodes/tools/g4_sampling_diagnostic_node/node.py
T
chris.dumas bf8f76505f Squashed 'vendor/dumas_h3_continuum/' content from commit d07ed31
git-subtree-dir: vendor/dumas_h3_continuum
git-subtree-split: d07ed31b442d283d6a1740f875a843b9feda4c91
2026-10-20 13:43:38 +00:00

647 lines
24 KiB
Python

"""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",
}