""" Model Factory for public architectures used in this release. """ from pathlib import Path import timm import torch import torch.nn as nn import torchvision.models as models from torchvision.models import ( DenseNet121_Weights, EfficientNet_B0_Weights, ResNet18_Weights, ResNet34_Weights, ResNet50_Weights, Swin_B_Weights, ) from config.experiment_config import MODEL_DEFAULTS class MultiTaskHead(nn.Module): """Legacy fallback head used when biomarker_config is not provided.""" def __init__(self, input_dim, num_binary_tasks=7, num_calcium_classes=4, num_regression_tasks=2, dropout=0.1): super().__init__() self.shared_layers = nn.Sequential( nn.Linear(input_dim, 512), nn.ReLU(inplace=True), nn.Dropout(dropout), nn.BatchNorm1d(512), ) self.binary_head = nn.Linear(512, num_binary_tasks) self.calcium_head = nn.Linear(512, num_calcium_classes) self.regression_head = nn.Linear(512, num_regression_tasks) def forward(self, x): shared = self.shared_layers(x) binary_out = self.binary_head(shared) calcium_out = self.calcium_head(shared) regression_out = self.regression_head(shared) return torch.cat([binary_out, calcium_out, regression_out], dim=1) class ModelFactory: """Factory class for supported public model architectures.""" SUPPORTED_ARCHITECTURES = tuple(MODEL_DEFAULTS.keys()) @staticmethod def create_model( architecture, num_classes=13, pretrained_weights=None, fine_tuning_strategy="full", dropout=0.1, biomarker_config=None, single_target_strategy=None, target_feature_dim=None, single_target_output_dim=None, **kwargs, ): """Create model based on architecture specification.""" if single_target_output_dim is not None: target_feature_dim = single_target_output_dim if architecture == "ResNet-18": return ModelFactory._create_resnet18( num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) if architecture == "ResNet-34": return ModelFactory._create_resnet34( num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) if architecture == "DenseNet-121": return ModelFactory._create_densenet121( num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) if architecture == "EfficientNet-B0": return ModelFactory._create_efficientnet_b0( num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) if architecture == "ViT-Small (DINOv2)": return ModelFactory._create_dinov2_vit( architecture, num_classes, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) if architecture == "Swin Transformer-Base": return ModelFactory._create_swin_base( num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) if architecture == "ResNet-50 (RadImageNet)": return ModelFactory._create_resnet50_radimgnet( num_classes, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy, target_feature_dim, ) raise ValueError( f"Unsupported architecture: {architecture}. " f"Supported: {list(ModelFactory.SUPPORTED_ARCHITECTURES)}" ) @staticmethod def _create_multitask_head(feature_dim, dropout, biomarker_config, head_type="flexible", single_target_strategy=None, target_feature_dim=None): if biomarker_config is not None: if head_type == "linear_probe": from .flexible_multitask_head import LinearProbeMultiTaskHead return LinearProbeMultiTaskHead( feature_dim, biomarker_config, dropout=dropout, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) from .flexible_multitask_head import FlexibleMultiTaskHead return FlexibleMultiTaskHead( feature_dim, biomarker_config, dropout=dropout, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) return MultiTaskHead(feature_dim, dropout=dropout) @staticmethod def _freeze_for_linear_probe(model, head_module): for param in model.parameters(): param.requires_grad = False for param in head_module.parameters(): param.requires_grad = True @staticmethod def _create_resnet18(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" if pretrained_weights == "ImageNet": model = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1) else: model = models.resnet18(weights=None) model.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) feature_dim = model.fc.in_features model.fc = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type, single_target_strategy, target_feature_dim ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.fc) return model @staticmethod def _create_resnet34(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" if pretrained_weights == "ImageNet": model = models.resnet34(weights=ResNet34_Weights.IMAGENET1K_V1) else: model = models.resnet34(weights=None) model.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) feature_dim = model.fc.in_features model.fc = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type, single_target_strategy, target_feature_dim ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.fc) return model @staticmethod def _create_densenet121(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config=None, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" if pretrained_weights == "ImageNet": model = models.densenet121(weights=DenseNet121_Weights.IMAGENET1K_V1) else: model = models.densenet121(weights=None) feature_dim = model.classifier.in_features model.classifier = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type=head_type, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.classifier) return model @staticmethod def _create_efficientnet_b0(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config=None, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" if pretrained_weights == "ImageNet": model = models.efficientnet_b0(weights=EfficientNet_B0_Weights.IMAGENET1K_V1) else: model = models.efficientnet_b0(weights=None) feature_dim = model.classifier[1].in_features model.classifier = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type=head_type, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.classifier) return model @staticmethod def _create_dinov2_vit(architecture, num_classes, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" model = timm.create_model("vit_small_patch14_dinov2", pretrained=True, num_classes=0, img_size=256) feature_dim = model.num_features model.head = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type=head_type, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.head) return model @staticmethod def _create_swin_base(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config=None, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" if pretrained_weights == "ImageNet-22K": model = models.swin_b(weights=Swin_B_Weights.IMAGENET1K_V1) else: model = models.swin_b(weights=None) model.features[0][0] = nn.Conv2d(1, 128, kernel_size=4, stride=4) feature_dim = model.head.in_features model.head = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type=head_type, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.head) return model @staticmethod def _create_resnet50_radimgnet(num_classes, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None): head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible" ckpt_path = ( Path(__file__).resolve().parents[1] / "radimagenet_ckpt" / "resnet50" / "ResNet50_RadImageNet.pt" ) try: if ckpt_path.exists(): model = models.resnet50(weights=None) checkpoint = torch.load(str(ckpt_path), map_location="cpu") state_dict = checkpoint.get("model", checkpoint.get("state_dict", checkpoint)) model_state_dict = model.state_dict() filtered_state_dict = {} for key, value in state_dict.items(): if key.startswith("fc.") or key.startswith("classifier."): continue mapped_key = key if key.startswith("backbone."): mapped_key = key[9:] if mapped_key.startswith("4."): mapped_key = "layer1." + mapped_key[2:] elif mapped_key.startswith("5."): mapped_key = "layer2." + mapped_key[2:] elif mapped_key.startswith("6."): mapped_key = "layer3." + mapped_key[2:] elif mapped_key.startswith("7."): mapped_key = "layer4." + mapped_key[2:] elif mapped_key.startswith("0."): mapped_key = "conv1." + mapped_key[2:] elif mapped_key.startswith("1."): mapped_key = "bn1." + mapped_key[2:] elif key.startswith("features."): mapped_key = key[9:] if mapped_key in model_state_dict: filtered_state_dict[mapped_key] = value model.load_state_dict(filtered_state_dict, strict=False) else: model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1) except Exception: model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1) feature_dim = model.fc.in_features model.fc = ModelFactory._create_multitask_head( feature_dim, dropout, biomarker_config, head_type=head_type, single_target_strategy=single_target_strategy, target_feature_dim=target_feature_dim, ) if fine_tuning_strategy == "linear_probe": ModelFactory._freeze_for_linear_probe(model, model.fc) return model def get_model_memory_requirement(architecture): """Get expected GPU memory requirement for supported public architectures.""" memory_map = { "ResNet-18": "4-6GB", "ResNet-34": "6-8GB", "DenseNet-121": "8-10GB", "EfficientNet-B0": "6-8GB", "ViT-Small (DINOv2)": "8-10GB", "Swin Transformer-Base": "12-16GB", "ResNet-50 (RadImageNet)": "6-8GB", } return memory_map.get(architecture, "Unknown")