পাঠ ৩৪ · ৩৫-এর মধ্যে · মডিউল ৪

Home / AI Courses / Computer Vision / Project: medical segmentation

প্রজেক্ট: medical image segmentation

Project: chest X-ray lung segmentation with U-Net

১৫ মিনিট পড়া উচ্চ · Advanced Project

এই project-এ যা করবেন

Medical dataset preprocess
U-Net training with Dice loss
Augmentation, evaluation
Bangladesh hospital deployment consideration

১ · Project scope

Chest X-ray → both lung mask।
Application: TB screening, COVID lesion area, pneumonia।
Bangladesh need — TB high prevalence, radiologist shortage।

Why medical CV matters in Bangladesh

ICDDR,B, BIRDEM, BSMMU — research আছে। 1 radiologist per ~50,000 people। AI-assisted screening — rural area-এ life-saving। Responsible deployment essential।

২ · Dataset

Montgomery Country (MC): 138 chest X-ray, lung mask annotated। Public NIH।
Shenzhen: 662 chest X-ray (Bangladesh-relevant, TB cases)।
JSRT: 247 X-ray, lung + heart mask।
NIH ChestX-ray14: 100K X-ray (no mask)।
Bangladesh data: ICDDR,B partnership essential for local validation।

৩ · Preprocessing

Python · OpenCV

import cv2
import numpy as np

def preprocess_xray(img_path, target_size=512):
    img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)

    # Histogram equalization — contrast enhance
    img = cv2.equalizeHist(img)

    # Or CLAHE — adaptive
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
    img = clahe.apply(img)

    # Resize maintaining aspect ratio
    h, w = img.shape
    scale = target_size / max(h, w)
    new_h, new_w = int(h*scale), int(w*scale)
    img = cv2.resize(img, (new_w, new_h))

    # Pad to square
    pad_h = target_size - new_h
    pad_w = target_size - new_w
    img = cv2.copyMakeBorder(img, pad_h//2, pad_h-pad_h//2,
                              pad_w//2, pad_w-pad_w//2,
                              cv2.BORDER_CONSTANT, value=0)

    # Normalize
    img = img.astype(np.float32) / 255.0
    return img

৪ · U-Net with ResNet encoder

Python · PyTorch + segmentation_models

# pip install segmentation-models-pytorch
import segmentation_models_pytorch as smp
import torch

model = smp.Unet(
    encoder_name="resnet50",        # ImageNet pretrained
    encoder_weights="imagenet",
    in_channels=1,                   # grayscale X-ray
    classes=1,                       # binary mask (lung vs background)
    activation=None                  # apply sigmoid externally
)

# Test
x = torch.randn(1, 1, 512, 512)
y = model(x)
print("Output:", y.shape)            # (1, 1, 512, 512)

৫ · Loss function

Python · PyTorch

import torch
import torch.nn as nn

class DiceBCELoss(nn.Module):
    def __init__(self, dice_weight=0.5):
        super().__init__()
        self.bce = nn.BCEWithLogitsLoss()
        self.dice_weight = dice_weight

    def forward(self, pred, target):
        bce = self.bce(pred, target)

        pred_sig = torch.sigmoid(pred)
        smooth = 1.0
        intersection = (pred_sig * target).sum()
        dice = 1 - (2*intersection + smooth) / (pred_sig.sum() + target.sum() + smooth)

        return bce + self.dice_weight * dice

criterion = DiceBCELoss(dice_weight=0.5)

Dice — class imbalance robust। BCE — pixel confidence। Combined — best of both।

৬ · Training loop

Python · PyTorch

from torch.utils.data import DataLoader
from torch.optim import AdamW
from torch.optim.lr_scheduler import CosineAnnealingLR

# Train setup
model = model.to('cuda')
optimizer = AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)
scheduler = CosineAnnealingLR(optimizer, T_max=50)

train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=8)

best_dice = 0
for epoch in range(50):
    model.train()
    train_loss = 0
    for images, masks in train_loader:
        images, masks = images.to('cuda'), masks.to('cuda')
        optimizer.zero_grad()
        pred = model(images)
        loss = criterion(pred, masks)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()

    # Validation
    model.eval()
    val_dice = 0
    with torch.no_grad():
        for images, masks in val_loader:
            images, masks = images.to('cuda'), masks.to('cuda')
            pred = torch.sigmoid(model(images))
            pred_bin = (pred > 0.5).float()
            dice = (2 * (pred_bin * masks).sum() + 1) / (pred_bin.sum() + masks.sum() + 1)
            val_dice += dice.item()

    val_dice /= len(val_loader)
    scheduler.step()

    print(f"Epoch {epoch+1}: train_loss={train_loss/len(train_loader):.4f}, val_dice={val_dice:.4f}")

    if val_dice > best_dice:
        best_dice = val_dice
        torch.save(model.state_dict(), 'best_lung_unet.pth')

৭ · Augmentation

import albumentations as A

train_transform = A.Compose([
    A.Resize(512, 512),
    A.HorizontalFlip(p=0.5),                  # safe (chest symmetry-ish)
    A.Rotate(limit=10, p=0.5),                # small rotation
    A.RandomBrightnessContrast(p=0.3),
    A.GaussNoise(var_limit=0.01, p=0.3),
    A.ElasticTransform(alpha=1, sigma=50, p=0.2),  # tissue elasticity
    A.Normalize(mean=[0.5], std=[0.25]),
])

Avoid: vertical flip (heart asymmetry), large rotation (>30°)।

৮ · Evaluation metrics

Dice coefficient: 2|A∩B| / (|A|+|B|) — primary।
IoU: Jaccard index।
Sensitivity (recall): TP / (TP + FN) — miss critical।
Specificity: TN / (TN + FP) — false alarm।
Hausdorff distance: boundary precision।

Medical priority: high sensitivity (don't miss disease) over specificity (false alarm OK)।

Medical AI = "second opinion to radiologist" — replacement nয়। Dice 0.95 doesn't mean clinical accuracy। Real-world validation, FDA pathway, clinician trust — all required।

Medical AI project — research-grade থেকে clinical-grade-এ পথ। Bangladesh DGDA regulatory framework।

৯ · DICOM handling

Hospital-এ X-ray DICOM format — 12-16 bit, metadata। Conversion essential।

# pip install pydicom
import pydicom
import numpy as np

def load_dicom(path):
    ds = pydicom.dcmread(path)
    img = ds.pixel_array

    # 16-bit → 8-bit windowing
    # Use DICOM window center/width if present
    wc = ds.get('WindowCenter', np.median(img))
    ww = ds.get('WindowWidth', img.max() - img.min())

    img_min = wc - ww/2
    img_max = wc + ww/2
    img = np.clip(img, img_min, img_max)
    img = ((img - img_min) / (img_max - img_min) * 255).astype(np.uint8)

    return img, ds  # also return metadata

১০ · Inference + visualize

def predict_lung_mask(img_path, model_path='best_lung_unet.pth'):
    model = smp.Unet(encoder_name="resnet50", in_channels=1, classes=1)
    model.load_state_dict(torch.load(model_path))
    model.eval().cuda()

    img = preprocess_xray(img_path)
    img_tensor = torch.tensor(img).unsqueeze(0).unsqueeze(0).cuda()

    with torch.no_grad():
        pred = torch.sigmoid(model(img_tensor))
        mask = (pred > 0.5).cpu().numpy()[0, 0]

    # Calculate lung area (cm² estimate)
    lung_pixel_count = mask.sum()
    return mask, lung_pixel_count

১১ · Bangladesh deployment consideration

Regulatory:

DGDA approval: Bangladesh Directorate General of Drug Administration।
Software as Medical Device — clarify level।
Multi-site validation।

Hospital integration:

PACS (Picture Archiving) integration।
HIS (Hospital Information System) interface।
HL7/DICOM compliance।
Workflow seamless।

Clinical validation:

3+ radiologist concordance।
Bangladeshi patient demographic data।
Edge case analysis।
Failure mode documentation।

Ethics:

BMRC (Bangladesh Medical Research Council) approval।
Patient consent।
Data anonymization।
Bias audit।

১২ · Bangladesh-specific challenges

Image quality: rural hospital — older X-ray equipment, more noise।
Demographic: Bangladesh chest morphology — need local data validation।
TB prevalence: high — model bias toward TB-positive may overconfide।
Compute infrastructure: rural — offline inference essential।
Internet: intermittent — local server needed।

১৩ · Beyond lung — extensions

TB lesion detect: next layer।
COVID lesion: pneumonia distinguishing।
Pneumothorax: emergency।
Cardiomegaly: heart enlargement।
Multi-class: all in one model।

Medical AI deploy responsible — not just accurate। Misdiagnosis liability, regulatory hurdle, ethics critical। Bangladesh ICDDR,B, BSMMU partnership essential।

ভাবনার প্রশ্ন

প্র ০১ Medical AI accuracy 95%+ হলেও hospital deploy অনেক years lag-এ। কেন?

"AI hype" vs "clinical reality" gap — major barriers।

Validation gap:

Lab dataset ≠ hospital reality।
Prospective trial — months to years।
Multi-site validation।

Regulatory complexity:

FDA/CE/DGDA approval — 2-5 year typical।
Documentation extensive।
Software-as-medical-device classification।
Update protocol challenge (modeling drift)।

Clinical workflow:

Doctor habit — change resistance।
EMR integration — IT cost।
Liability — who responsible if error?
Reimbursement code — insurance।

Bias risk:

Training demographic — deployment population mismatch।
Equipment variation।
Edge case undocumented।

Trust building:

Explainability — Grad-CAM, attention map।
Calibrated confidence — when uncertain, say so।
Failure mode transparent।

Bangladesh specific:

DGDA framework gradually maturing।
Local validation cohort essential।
Pilot program (BIRDEM, NCC) longer।
Engineer + clinician collaboration critical।

Cost-benefit reality:

Bangladesh — radiologist scarcity makes AI valuable।
Rural deployment particular need।
Cost-effective vs urban radiologist visit।

মূল উপলব্ধি: Medical AI — high accuracy necessary not sufficient। Trust, workflow, regulatory — clinical adoption-এর co-equal challenges।

প্র ০২ Dice loss vs cross-entropy — medical-এ কেন Dice prefer? Limitations?

Loss function selection — medical CV-র subtle but critical decision।

Cross-entropy issues:

Per-pixel — class imbalance dominate background।
Lung segment 30% pixel typical — borderline OK।
Tumor segment 1% pixel — fail।

Dice advantage:

Ratio-based — class size invariant।
Direct optimize evaluation metric।
Foreground-focused।

Dice limitations:

Discontinuous gradient at zero overlap।
Boundary refinement-এ weak gradient।
Sensitivity to small object।

Combined Dice + BCE:

BCE — pixel-level confidence signal।
Dice — overlap-level optimize।
Best of both।

Other medical loss:

Tversky: $\alpha, \beta$ — false positive/negative weight।
Focal Tversky: hard case focus।
Hausdorff loss: boundary precision।
Boundary loss: edge-aware।

Per-task selection:

Lung segment (30% pixel): BCE + Dice OK।
Tumor (1% pixel): Dice + Focal।
Boundary critical: + boundary loss।

Hyperparameter:

Dice weight 0.3-0.7 typical।
Trade-off pixel accuracy vs overlap।

মূল উপলব্ধি: Loss = task encode mathematical। Dice = overlap-aware। Medical task structure-aware loss critical।

প্র ০৩ Bangladesh hospital pilot — 100 patient। Promising। Scale up — কী challenge?

Pilot to scale — most ML projects fail here।

Pilot success factors:

Curated dataset।
Experienced team।
Best equipment।
Single hospital culture।

Scale challenges:

Equipment variability: different X-ray machine — calibration ভিন্ন।
Patient diversity: rural vs urban, demographic, comorbidity।
Workflow variation: protocol differ across hospital।
Operator skill: X-ray technician training varies।
IT infrastructure: some no PACS, internet poor।

Specific issues:

Domain shift — accuracy drops 10-20%।
Edge cases unanticipated।
Confidence calibration off।
UI/UX assumptions wrong।

Mitigation:

Multi-site dataset: 5-10 hospital cohort।
Continuous learning: failure case retrain।
Calibration layer: per-site confidence adjust।
Human-in-the-loop: low confidence radiologist review।
Monitoring dashboard: performance per site track।

Bangladesh roadmap:

Pilot: 100 patient single hospital (BIRDEM)।
Validation: 1000 patient, 5 hospital।
Multi-site cohort: 10K patient।
DGDA submission।
Scale-up: nationwide।

Stakeholders:

Government (Health Ministry)।
Hospital administration।
Doctor, technician training।
Patient education।
Insurance company।

Cost reality:

Pilot: $50K-100K।
Validation: $500K-1M।
Scale: $5M+।
Funding: USAID, GAVI, Gates Foundation common।

মূল উপলব্ধি: "Pilot success ≠ scale success"। Bangladesh medical AI — multi-stakeholder, multi-year journey। Engineering 30%, rest sociology, regulation, business।

প্র ০৪ "Explainable AI" medical-এ critical। Grad-CAM, attention map কীভাবে use? Limitation?

Medical AI trust — transparency essential।

Grad-CAM (২০১৬):

"Where did model look?" heatmap।
Gradient-based attribution।
Last conv layer activation × gradient।
Coarse but interpretable।

Implementation:

from pytorch_grad_cam import GradCAM

target_layer = model.encoder.layer4
cam = GradCAM(model=model, target_layers=[target_layer])
grayscale_cam = cam(input_tensor=img, targets=None)[0, :]
# Overlay on original image

Use cases:

Doctor verify — model focusing on relevant region।
Failure case analyze — model confused by what।
Trust building।

Other techniques:

SHAP: per-pixel contribution।
LIME: local linear approximation।
Attention map (transformer): direct attention weight।
Counterfactual: "what would change prediction?"।

Limitations:

Coarse — pixel-level attribution rough।
Method-dependent — different XAI different output।
Confirmation bias — radiologist looks where model points।
Pseudo-explanation — model may attend wrong region but predict right।

Best practice:

Multi-method comparison।
Sanity check — random model XAI compare।
Quantitative metric (Pointing Game)।
Doctor + AI joint decision।

Calibration:

Confidence score reliable চাই।
Temperature scaling।
Conformal prediction।
"95% confident" actually 95% accurate।

Regulatory:

EU AI Act — explainability requirement।
FDA — increasing focus।
DGDA — emerging framework।

মূল উপলব্ধি: Black-box ≠ acceptable in medicine। XAI imperfect but essential। Engineering responsibility — interpretable system build।

অনুশীলন

Setup: Montgomery dataset download, U-Net train baseline।

Code section ৪-৬। Free Colab GPU 2-3 hour। Final Dice ~0.95 expected।
Visualize: Test image-এ predict + Grad-CAM overlay।

pytorch-grad-cam library use। Lung region attention concentrate confirm।
ভাবুন: ICDDR,B-এ TB screening AI deploy — কী additional steps medical-grade হতে?

(1) Multi-site Bangladesh data collect। (2) BMRC ethics approval। (3) Radiologist concordance study। (4) Workflow integration। (5) DGDA submission। (6) Continuous monitoring। 2-3 year timeline minimum।