| from __future__ import annotations |
|
|
| import torch |
| from torch import nn |
|
|
| from .clinical_encoder import ClinicalEncoder |
| from .ct_encoder import CTEncoder |
| from .fusion import SelectivePETFusion |
| from .pet_encoder import PETEncoder |
| from .support_net import SupportNet |
| from .survival_head import DiscreteTimeSurvivalHead |
|
|
|
|
| class CohortAwareCTModel(nn.Module): |
| """End-to-end model matching the paper's first-stage reproducible modules.""" |
|
|
| def __init__( |
| self, |
| in_channels: int = 1, |
| feature_dim: int = 256, |
| clinical_dim: int = 0, |
| survival_bins: int = 0, |
| use_pet: bool = True, |
| use_support: bool = True, |
| clinical_use_missingness: bool = True, |
| gate_mode: str = "selective", |
| ) -> None: |
| super().__init__() |
| self.use_pet = use_pet |
| self.use_support = use_support |
| self.support_net = SupportNet(in_channels=in_channels) |
| self.ct_encoder = CTEncoder(in_channels=in_channels + 1, feature_dim=feature_dim) |
| self.pet_encoder = PETEncoder(in_channels=1, feature_dim=feature_dim) if use_pet else None |
| self.clinical_encoder = ClinicalEncoder( |
| clinical_dim=clinical_dim, |
| feature_dim=feature_dim, |
| use_missingness=clinical_use_missingness, |
| ) |
| self.fusion = SelectivePETFusion(feature_dim=feature_dim, gate_mode=gate_mode) |
| self.survival_head = ( |
| DiscreteTimeSurvivalHead(in_dim=feature_dim * 3, num_bins=survival_bins) |
| if survival_bins > 0 |
| else None |
| ) |
|
|
| def forward(self, batch: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]: |
| ct = batch["ct"].float() |
| support_logits = self.support_net(ct) |
| support_prob = torch.sigmoid(support_logits) if self.use_support else torch.zeros_like(support_logits) |
| ct_feat = self.ct_encoder(torch.cat([ct, support_prob], dim=1)) |
|
|
| clinical_feat = self.clinical_encoder(batch.get("clinical"), batch.get("clinical_missing")) |
| pet_feat = None |
| if self.use_pet and self.pet_encoder is not None and "pet" in batch: |
| pet_feat = self.pet_encoder(batch["pet"].float()) |
|
|
| out = self.fusion( |
| ct_feat=ct_feat, |
| clinical_feat=clinical_feat, |
| pet_feat=pet_feat, |
| has_pet=batch.get("has_pet") if self.use_pet else torch.zeros(ct_feat.shape[0], device=ct_feat.device), |
| ) |
| out["support_logits"] = support_logits |
| out["support_prob"] = support_prob |
| out["lesion_prob"] = torch.sigmoid(out["fused_logit"]) |
| if self.survival_head is not None: |
| out["hazard_logits"] = self.survival_head(out["fused_features"]) |
| return out |
|
|
