Download ComfyUI-H3ZeroStudio-Lab/tests/test_memory.py from p3cyc/minimax: direct link, hf CLI and curl.
- Browser
- Download file 6.49 kB
-
https://huggingface.co/p3cyc/minimax/resolve/main/ComfyUI-H3ZeroStudio-Lab/tests/test_memory.py
- Command line
-
hf download hf://p3cyc/minimax/ComfyUI-H3ZeroStudio-Lab/tests/test_memory.py
-
curl -L -o test_memory.py https://huggingface.co/p3cyc/minimax/resolve/main/ComfyUI-H3ZeroStudio-Lab/tests/test_memory.py
6.49 kB
| """v6m memory policy: «Экономия памяти» (chunked feed-forward, own implementation) and releasing what a run does | |
| not need (ControlNet patch, preprocessors) with a short log line.""" | |
| import torch | |
| import pytest | |
| from h3s import h3s_core as core | |
| from h3s import h3s_gen as gen | |
| from h3s import h3s_control as control | |
| from h3s import h3s_memory as mem | |
| from fakes import tiny_patcher, FakeClip, FakeVAE | |
| from test_control import dirs, project, _video, _pinfo # noqa: F401 (fixtures) | |
| def patcher(): | |
| return tiny_patcher() | |
| def test_chunked_ffn_equals_the_plain_mlp(patcher): | |
| import comfy.ops | |
| mlp = patcher.model.diffusion_model.blocks[0].mlp | |
| torch.manual_seed(1) | |
| for shape in ((1, 1031, 128), (1037, 128), (2, 600, 128)): | |
| x = torch.randn(*shape) | |
| ref = comfy.ops.linear_input_act(mlp.fc2, mlp.fc1(x), "swiglu") | |
| for chunks in (2, 3, 7): | |
| got = mem.chunked_ffn(chunks, 256)(mlp, x) | |
| assert got.shape == ref.shape and torch.allclose(got, ref, atol=1e-6, rtol=1e-5), (shape, chunks) | |
| small = torch.randn(1, 100, 128) # under the threshold: the plain path | |
| assert torch.equal(mem.chunked_ffn(4, 256)(mlp, small), comfy.ops.linear_input_act(mlp.fc2, mlp.fc1(small), "swiglu")) | |
| def test_modes_and_the_patched_clone(patcher): | |
| assert not mem.wants_ffn({"mode": "off"}, cn=True, tokens=10 ** 6) | |
| assert mem.wants_ffn({"mode": "auto"}, cn=True) and not mem.wants_ffn({"mode": "auto"}, cn=False, tokens=100) | |
| assert mem.wants_ffn({"mode": "auto", "threshold": 1000}, tokens=2001) and mem.wants_ffn({"mode": "on"}) | |
| assert mem.apply_ffn(patcher, {"mode": "off"}) is patcher | |
| m2 = mem.apply_ffn(patcher, {"mode": "on", "chunks": 2, "threshold": 512}) | |
| assert m2 is not patcher and not patcher.object_patches # the source patcher is untouched | |
| keys = [k for k in m2.object_patches if k.endswith(".mlp.forward")] | |
| assert len(keys) == len(patcher.model.diffusion_model.blocks) | |
| assert mem.apply_ffn(m2, {"mode": "on"}) is m2 # never stacked | |
| assert core.normalize_project({"settings": {"memsave": {"mode": "x", "chunks": 99, "threshold": 5}}})["settings"]["memsave"] == {"mode": "auto", "chunks": 16, "threshold": 256} | |
| def test_generation_with_memsave_gives_the_same_latents(patcher, dirs, monkeypatch): | |
| out, inp = dirs | |
| seen = [] | |
| real = mem.chunked_ffn | |
| def spy(chunks, thr): | |
| f = real(chunks, thr) | |
| def g(self, x): | |
| seen.append(int(x.shape[-2])) | |
| return f(self, x) | |
| g._h3zs_ffn = f._h3zs_ffn | |
| return g | |
| monkeypatch.setattr(mem, "chunked_ffn", spy) | |
| base = project() | |
| base["settings"]["cache"] = False | |
| base["settings"]["memsave"] = {"mode": "off"} | |
| a = gen.run_project(patcher, FakeClip(), FakeVAE(), base) | |
| assert not seen | |
| on = project() | |
| on["settings"]["cache"] = False | |
| on["settings"]["memsave"] = {"mode": "on", "chunks": 3, "threshold": 256} | |
| monkeypatch.setattr(core, "normalize_memsave", lambda v: {"mode": "on", "chunks": 3, "threshold": 8}) # tiny clips: force chunking | |
| b = gen.run_project(patcher, FakeClip(), FakeVAE(), on) | |
| assert seen and max(seen) > 8 | |
| va, vb = a[0], b[0] | |
| assert torch.allclose(va, vb, atol=1e-4, rtol=1e-4) | |
| class _FakePatcher: | |
| def __init__(self, name): | |
| self.name, self.model = name, object() | |
| def test_release_unloads_and_logs(monkeypatch, capsys): | |
| import comfy.model_management as mm | |
| gone = [] | |
| monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a, **k: gone.append(p.name), raising=False) | |
| mem.hold("cn_patch:x.safetensors", _FakePatcher("cn"), "ControlNet patch x") | |
| mem.hold("pre:pose", (_FakePatcher("sdpose"), None, _FakePatcher("rtdetr")), "SDPose + RT-DETR") | |
| control.release() | |
| assert sorted(gone) == ["rtdetr", "sdpose"] and mem.get("cn_patch:x.safetensors") is not None | |
| control.release_patch() | |
| assert gone[-1] == "cn" and not mem.HOT | |
| assert "[H3ZS] unloaded: SDPose + RT-DETR" in capsys.readouterr().out | |
| def test_preprocessors_are_released_right_after_the_control_video(dirs, monkeypatch): | |
| out, inp = dirs | |
| a = _video(inp) | |
| held = [] | |
| monkeypatch.setattr(control, "preprocess", lambda fr, mode, params: (mem.get("pre:da3:x") or mem.hold("pre:da3:x", _FakePatcher("da3")), fr)[1]) | |
| import comfy.model_management as mm | |
| monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a_, **k: held.append(p.name), raising=False) | |
| path = control.build_processed(str(inp / "h3labstudio" / a["file"]), "depth", core.normalize_control_params({})) | |
| assert path and held == ["da3"] and mem.get("pre:da3:x") is None | |
| def test_run_without_control_releases_the_patch(patcher, dirs, monkeypatch): | |
| import comfy.model_management as mm | |
| gone = [] | |
| monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a, **k: gone.append(p.name), raising=False) | |
| mem.hold("cn_patch:fake_2.0.safetensors", _FakePatcher("cn"), "ControlNet patch") | |
| gen.run_project(patcher, FakeClip(), FakeVAE(), project()) | |
| assert gone == ["cn"] and not any(k.startswith("cn_patch:") for k in mem.HOT) | |
| def test_run_with_control_keeps_the_patch_hot(patcher, dirs, monkeypatch): | |
| out, inp = dirs | |
| _video(inp) | |
| import comfy.model_management as mm | |
| import comfy_extras.nodes_minimax_h3 as nm | |
| gone, loads = [], [] | |
| monkeypatch.setattr(mm, "unload_model_and_clones", lambda p, *a, **k: gone.append(p.name), raising=False) | |
| class FakeApply: | |
| def execute(model, patch, vae, strength, start, end, control_video=None): | |
| return (model,) | |
| monkeypatch.setattr(nm, "MiniMaxH3FunControlNetApply", FakeApply) | |
| monkeypatch.setattr(control, "patch_file", lambda: ("fake_2.0.safetensors", "/x")) | |
| monkeypatch.setattr(control, "patch_info", _pinfo("fake_2.0.safetensors")) | |
| import comfy_extras.nodes_model_patch as mp | |
| class FakeLoader: | |
| def load_model_patch(self, name): | |
| loads.append(name) | |
| return (_FakePatcher("cn"),) | |
| monkeypatch.setattr(mp, "ModelPatchLoader", FakeLoader) | |
| p = project({"mode": "gray", "clips": [{"asset": "v1", "start": 0.0, "in": 0.0, "length": 1.0}]}) | |
| p["settings"]["cache"] = False | |
| gen.run_project(patcher, FakeClip(), FakeVAE(), p) | |
| gen.run_project(patcher, FakeClip(), FakeVAE(), p) | |
| assert loads == ["fake_2.0.safetensors"] and gone == [] # same setup: loaded once, no churn | |
| control.release_patch() | |