| from __future__ import annotations |
|
|
| import torch |
| from torch import nn |
|
|
|
|
| class SelectivePETFusion(nn.Module): |
| """CT-first PET fusion with a learned PET utility gate. |
| |
| The final fused representation is a convex mix between CT+clinical and |
| CT+PET+clinical features. During training, the gate can be supervised by a |
| pseudo-label derived from CT-only versus PET-enabled validation gain. |
| """ |
|
|
| def __init__(self, feature_dim: int = 256, num_heads: int = 4, gate_mode: str = "selective") -> None: |
| super().__init__() |
| if gate_mode not in {"selective", "always", "never"}: |
| raise ValueError(f"Unsupported gate_mode: {gate_mode}") |
| self.gate_mode = gate_mode |
| self.attn = nn.MultiheadAttention(feature_dim, num_heads=num_heads, batch_first=True) |
| self.ct_head = nn.Linear(feature_dim * 2, 1) |
| self.pet_head = nn.Linear(feature_dim * 3, 1) |
| self.utility_head = nn.Sequential( |
| nn.Linear(feature_dim * 3, feature_dim), |
| nn.SiLU(inplace=True), |
| nn.Linear(feature_dim, 1), |
| ) |
|
|
| def forward( |
| self, |
| ct_feat: torch.Tensor, |
| clinical_feat: torch.Tensor, |
| pet_feat: torch.Tensor | None = None, |
| has_pet: torch.Tensor | None = None, |
| ) -> dict[str, torch.Tensor]: |
| ct_context = torch.cat([ct_feat, clinical_feat], dim=-1) |
| ct_logit = self.ct_head(ct_context).squeeze(-1) |
|
|
| if pet_feat is None: |
| zero_pet = torch.zeros_like(ct_feat) |
| pet_feat = zero_pet |
| tokens = torch.stack([ct_feat, pet_feat, clinical_feat], dim=1) |
| attended, _ = self.attn(tokens, tokens, tokens, need_weights=False) |
| fused = attended.reshape(attended.shape[0], -1) |
| pet_logit = self.pet_head(fused).squeeze(-1) |
| utility_logit = self.utility_head(fused).squeeze(-1) |
| utility = torch.sigmoid(utility_logit) |
| if self.gate_mode == "always": |
| utility = torch.ones_like(utility) |
| elif self.gate_mode == "never": |
| utility = torch.zeros_like(utility) |
| if has_pet is not None: |
| utility = utility * has_pet.float().view(-1) |
| fused_logit = ct_logit + utility * (pet_logit - ct_logit) |
| return { |
| "ct_logit": ct_logit, |
| "pet_logit": pet_logit, |
| "pet_utility_logit": utility_logit, |
| "pet_utility": utility, |
| "fused_logit": fused_logit, |
| "fused_features": fused, |
| } |
|
|
