CNN Architectures for Medical Image Analysis

Module: Healthcare AI | Difficulty: Advanced

Convolution Operation

2D Convolution (Discrete)

Receptive Field Growth

where is kernel size and is stride at layer .

Common Architectures for Medical Imaging

| Architecture | Depth | Parameters | Medical Task | Key Feature | |-------------|-------|------------|--------------|-------------| | ResNet-50 | 50 | 25.6M | Classification | Skip connections | | DenseNet-121 | 121 | 8M | Classification | Dense connections | | U-Net | ~20 | 31M | Segmentation | Skip connections | | EfficientNet-B4 | 47 | 19M | Classification | Compound scaling | | Swin Transformer | ~100 | 28M | Multi-task | Window attention |

import torch
import torch.nn as nn
import torchvision.models as models

class MedicalCNNClassifier(nn.Module):
    def __init__(self, num_classes=14, pretrained=True):
        super().__init__()
        backbone = models.densenet121(pretrained=pretrained)
        self.features = backbone.features
        num_features = backbone.classifier.in_features
        self.classifier = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(num_features, 512),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(512, num_classes)
        )

    def forward(self, x):
        features = self.features(x)
        features = nn.functional.adaptive_avg_pool2d(features, (1, 1))
        features = torch.flatten(features, 1)
        return self.classifier(features)

class AttentionBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.query = nn.Conv2d(channels, channels // 8, 1)
        self.key = nn.Conv2d(channels, channels // 8, 1)
        self.value = nn.Conv2d(channels, channels, 1)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        B, C, H, W = x.shape
        q = self.query(x).view(B, -1, H * W).permute(0, 2, 1)
        k = self.key(x).view(B, -1, H * W)
        attn = torch.softmax(q @ k / (C ** 0.5), dim=-1)
        v = self.value(x).view(B, C, -1)
        out = (v @ attn.permute(0, 2, 1)).view(B, C, H, W)
        return self.gamma * out + x

model = MedicalCNNClassifier(num_classes=14)
x = torch.randn(1, 3, 224, 224)
output = model(x)
print(f'Output shape: {output.shape}')

Research Insight: Hybrid architectures combining convolutional layers with self-attention mechanisms achieve superior performance on medical imaging tasks. The convolutional layers capture local texture features while attention layers model long-range dependencies, enabling more accurate diagnosis across diverse pathologies.