"""Label-free mixed-resolution/context ensemble inference, one OCT decode pass.""" import json import time import numpy as np import torch from torch.nn import functional as F from torch.utils.data import DataLoader from src.models import build_model, output_indices from src.inference.stream import OCTBatches from src.inference.runtime import autocast_options from src.inference.decoding import positions_from_logits from src.inference.combination import finish_positions, combine_named_heads from src.inference.writer import PredictionWriter def stream_ensemble( rows, root, checkpoint, output_dir, device, batch_size, workers, precision ): config = checkpoint["config"] members = [] for saved in checkpoint["members"]: cfg = saved["config"] model = build_model(cfg) model.load_state_dict(saved["model"]) model.to(device).eval().requires_grad_(False) members.append({"name": saved["name"], "config": cfg, "model": model}) if not members or len({m["name"] for m in members}) != len(members): raise ValueError("Invalid ensemble members") head_routes = config["combination"].get("head_source_by_device") active_by_device = {} if head_routes is not None: if set(head_routes) != set(config["device_keys"]): raise ValueError("Head-source device families differ") available = {member["name"] for member in members} for family, keys in config["device_keys"].items(): if set(head_routes[family]) != set(keys): raise ValueError("Head-source anatomical identities differ") active_by_device[family] = set(head_routes[family].values()) if not active_by_device[family] <= available: raise ValueError("Unknown selected head source") shapes = sorted( { ( m["config"]["height"], m["config"]["width"], m["config"].get("input_channels", 1), ) for m in members } ) loader = DataLoader( OCTBatches(rows, root, shapes, batch_size), batch_size=None, num_workers=workers, pin_memory=device.startswith("cuda"), **({"prefetch_factor": 2} if workers else {}) ) writer = PredictionWriter(output_dir, workers=2, maximum_pending_cases=2) # PredictionWriter uses named subdirectories; final files belong at root. pending = {} done = 0 start = time.monotonic() evaluated_frames = {} for batch in loader: index, offset = int(batch["index"]), int(batch["offset"]) b, h, a = map(int, batch["geometry"]) row = rows[index] n = len(batch["images"][0]) keys = config["device_keys"][row["device"]] if index not in pending: buffers = [] for member in members: if ( head_routes is not None and member["name"] not in active_by_device[row["device"]] ): continue cfg = member["config"] own_keys = cfg["device_keys"][row["device"]] if set(own_keys) != set(keys) or len(own_keys) != len(keys): raise ValueError("Ensemble boundary vocabulary differs") shape = (cfg["height"], cfg["width"], cfg.get("input_channels", 1)) buffers.append( { "member": member, "shape": shape, "indices": output_indices(cfg, row["device"]), "order": [own_keys.index(k) for k in keys], "positions": np.empty((len(keys), b, a), np.float32), } ) pending[index] = {"seen": np.zeros(b, bool), "buffers": buffers} state = pending[index] if offset + n > b or state["seen"][offset : offset + n].any(): raise ValueError("Invalid frame coverage") tensors = [image.to(device, non_blocking=True) for image in batch["images"]] with torch.inference_mode(), torch.autocast( **autocast_options(device, precision) ): for buffer in state["buffers"]: member = buffer["member"] cfg = member["config"] family_counts = evaluated_frames.setdefault(row["device"], {}) family_counts[member["name"]] = family_counts.get(member["name"], 0) + n position = positions_from_logits( member["model"](tensors[shapes.index(buffer["shape"])])[ :, buffer["indices"] ], cfg, row["device"], ) position = F.interpolate( position, size=a, mode="linear", align_corners=False ) position = ((position + 0.5) * h / cfg["height"] - 0.5).clamp(0, h - 1) values = position.float().cpu().numpy().transpose(1, 0, 2) buffer["positions"][:, offset : offset + n] = values[buffer["order"]] state["seen"][offset : offset + n] = True if state["seen"].all(): combination = config["combination"] components = [ finish_positions( item["positions"], row["device"], h, item["member"]["config"] .get("inference", {}) .get("postprocess", {}), ) for item in state["buffers"] ] values = combine_named_heads( components, [item["member"]["name"] for item in state["buffers"]], keys, row["device"], combination, ) values = finish_positions( values, row["device"], h, config.get("inference", {}).get("postprocess", {}), ) if not np.isfinite(values).all(): raise ValueError("Nonfinite ensemble output") writer.submit(row["case_id"], [("", values, keys)]) del pending[index] done += 1 if done % 10 == 0: print( json.dumps( { "completed_cases": done, "elapsed_seconds": time.monotonic() - start, } ), flush=True, ) writer.close() if pending or done != len(rows): raise ValueError("Incomplete ensemble input manifest") summary = { "completed_cases": done, "members": len(members), "elapsed_seconds": time.monotonic() - start, "evaluated_member_frames_by_device": evaluated_frames, "static_inactive_networks_skipped": head_routes is not None, } print(json.dumps(summary), flush=True) return summary