| """Checkpoint loading utilities for mixed timm/torchvision EfficientNet-B2 branches.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from pathlib import Path |
| from typing import Any |
|
|
| import torch |
| from torch import nn |
|
|
| CHECKPOINT_STATE_KEYS = ("encoder_state_dict", "model_state", "model_state_dict", "state_dict") |
| PREFIXES_TO_STRIP = ("module.", "model.", "encoder.", "backbone.", "_orig_mod.") |
|
|
|
|
| def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]: |
| if isinstance(checkpoint, dict): |
| for key in CHECKPOINT_STATE_KEYS: |
| value = checkpoint.get(key) |
| if isinstance(value, dict): |
| return value |
| if isinstance(checkpoint, dict) and all(torch.is_tensor(value) for value in checkpoint.values()): |
| return checkpoint |
| raise ValueError("Checkpoint does not contain a supported state dict.") |
|
|
|
|
| def load_raw_checkpoint(path: Path, device: torch.device, branch_name: str) -> Any: |
| if not path.exists(): |
| raise FileNotFoundError(f"{branch_name} checkpoint not found: {path}") |
| try: |
| return torch.load(path, map_location=device, weights_only=False) |
| except TypeError: |
| return torch.load(path, map_location=device) |
|
|
|
|
| def normalize_key(key: str) -> str: |
| changed = True |
| while changed: |
| changed = False |
| for prefix in PREFIXES_TO_STRIP: |
| if key.startswith(prefix): |
| key = key.removeprefix(prefix) |
| changed = True |
| return key |
|
|
|
|
| def infer_checkpoint_backend(path: Path, device: torch.device, branch_name: str) -> str: |
| checkpoint = load_raw_checkpoint(path, device, branch_name) |
| state = extract_state_dict(checkpoint) |
| keys = {normalize_key(key) for key in state} |
| timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.") |
| torchvision_prefixes = ("features.", "avgpool.", "classifier.") |
| timm_hits = sum(key.startswith(timm_prefixes) for key in keys) |
| torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys) |
| if timm_hits > torchvision_hits: |
| return "timm" |
| if torchvision_hits > timm_hits: |
| return "torchvision" |
| if any(key.startswith("layer") for key in keys): |
| return "timm" |
| raise RuntimeError( |
| f"{branch_name}: cannot infer checkpoint backend from {path}. " |
| "Pass --backbone-backend timm or --backbone-backend torchvision explicitly." |
| ) |
|
|
|
|
| def resolve_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]: |
| if args.backbone_backend != "auto": |
| return args.backbone_backend, args.backbone_backend |
|
|
| clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical") |
| dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic") |
| print(f"Auto-detected backbone backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}") |
| return clinical_backend, dermoscopic_backend |
|
|
|
|
| def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, device: torch.device) -> None: |
| checkpoint = load_raw_checkpoint(path, device, branch_name) |
| raw_state = extract_state_dict(checkpoint) |
| source_state = {normalize_key(key): value for key, value in raw_state.items()} |
| target_state = encoder.state_dict() |
| matched = { |
| key: value |
| for key, value in source_state.items() |
| if key in target_state and tuple(value.shape) == tuple(target_state[key].shape) |
| } |
| skipped = len(source_state) - len(matched) |
| if not matched: |
| raise RuntimeError(f"{branch_name}: no matching encoder weights loaded from {path}") |
|
|
| target_state.update(matched) |
| encoder.load_state_dict(target_state) |
| print(f"{branch_name}: loaded {len(matched)} keys from {path}; skipped {skipped} keys") |
|
|
