Spaces:
Sleeping
Sleeping
Download src/inference/ensemble.py from farrell236/OCT_Segmentation_a1: direct link, hf CLI and curl.
- Browser
- Download file 7.11 kB
-
https://huggingface.co/spaces/farrell236/OCT_Segmentation_a1/resolve/main/src/inference/ensemble.py
- Command line
-
hf download hf://spaces/farrell236/OCT_Segmentation_a1/src/inference/ensemble.py
-
curl -L -o ensemble.py https://huggingface.co/spaces/farrell236/OCT_Segmentation_a1/resolve/main/src/inference/ensemble.py
7.11 kB
| """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 | |