Machine Learning Jobs in Healthcare: Role Explained

# Medical imaging: chest X-ray classifier for pneumonia detection
# (the kind of model you build in healthcare ML roles)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
import torchvision.transforms as T
import torchvision.models as models

# 1. Data loading — standard medical imaging pipeline
transform = T.Compose([
    T.Resize(224),
    T.CenterCrop(224),
    T.ToTensor(),
    T.Normalize(
        mean=[0.485, 0.456, 0.406],  # ImageNet stats — common for medical too
        std=[0.229, 0.224, 0.225],
    ),
])

# 2. Use a pre-trained model with transfer learning
# (critical for healthcare — labelled medical data is scarce)
model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
model.fc = nn.Linear(model.fc.in_features, 2)  # pneumonia vs normal
model = model.to("cuda" if torch.cuda.is_available() else "cpu")

# 3. Loss with class weights — critical for imbalanced medical data
# (fewer pneumonia cases than normal — don't want to under-predict disease)
class_weights = torch.tensor([1.0, 3.5]).to(model.fc.weight.device)
loss_fn = nn.CrossEntropyLoss(weight=class_weights)

optimizer = optim.AdamW(model.parameters(), lr=1e-4)

# 4. Training loop
for epoch in range(10):
    model.train()
    running_loss = 0.0
    for images, labels in train_loader:
        images = images.to(model.fc.weight.device)
        labels = labels.to(model.fc.weight.device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

# 5. Evaluation — sensitivity (recall) matters more than accuracy in healthcare
# (missing a pneumonia case is much worse than a false positive)
model.eval()
correct, total = 0, 0
true_positives = true_negatives = false_positives = false_negatives = 0
with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(model.fc.weight.device)
        preds = model(images).argmax(dim=1).cpu()
        for p, l in zip(preds, labels):
            if p == 1 and l == 1: true_positives += 1
            elif p == 0 and l == 0: true_negatives += 1
            elif p == 1 and l == 0: false_positives += 1
            else: false_negatives += 1

sensitivity = true_positives / (true_positives + false_negatives)
specificity = true_negatives / (true_negatives + false_positives)

print(f"Sensitivity (recall): {sensitivity:.3f}")  # want > 0.95
print(f"Specificity: {specificity:.3f}")          # want > 0.85

# Real healthcare ML skills: transfer learning, imbalanced data,
# sensitivity/specificity reasoning, regulatory awareness.

# Risk prediction: 30-day hospital readmission model
# (the most common tabular ML problem in healthcare)

import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import (
    roc_auc_score, precision_score, recall_score, f1_score
)

# 1. Load EHR data (anonymised, HIPAA-compliant)
df = pd.read_parquet("s3://healthcare-lake/readmissions/")

# 2. Feature engineering — healthcare-specific
#    Age buckets, comorbidity scores, length of stay, prior admissions
df["age_bucket"] = pd.cut(df["age"], bins=[0, 18, 40, 60, 80, 120])
df["num_comorbidities"] = df[
    ["diabetes", "hypertension", "copd", "heart_disease"]
].sum(axis=1)
df["prior_admissions_12mo"] = df["admissions_12m"]
df["length_of_stay_days"] = (
    pd.to_datetime(df["discharge_date"]) - pd.to_datetime(df["admission_date"])
).dt.days
df["has_followup_scheduled"] = df["followup_date"].notna().astype(int)

# 3. Target: readmission within 30 days
df["target"] = (df["readmitted_within_30d"] == True).astype(int)

# 4. Split (stratified — preserves class ratio)
X = df[[
    "age_bucket", "num_comorbidities", "prior_admissions_12mo",
    "length_of_stay_days", "has_followup_scheduled",
    "num_medications", "has_diabetes", "has_hypertension",
]]
y = df["target"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# 5. Train XGBoost with class balancing
scale_pos_weight = (y_train == 0).sum() / (y_train == 1).sum()
model = xgb.XGBClassifier(
    n_estimators=300,
    max_depth=5,
    learning_rate=0.05,
    scale_pos_weight=scale_pos_weight,  # handles class imbalance
    eval_metric="auc",
)
model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    verbose=False,
)

# 6. Evaluate — AUC + threshold-based metrics (healthcare teams care about both)
probs = model.predict_proba(X_test)[:, 1]
auc = roc_auc_score(y_test, probs)

# Lower threshold to catch more high-risk patients (sensitivity-first)
threshold = 0.3
preds = (probs >= threshold).astype(int)
precision = precision_score(y_test, preds)
recall = recall_score(y_test, preds)
f1 = f1_score(y_test, preds)

print(f"AUC: {auc:.3f}")        # want > 0.75
print(f"Precision: {precision:.3f}")
print(f"Recall: {recall:.3f}")  # want > 0.70 in healthcare
print(f"F1: {f1:.3f}")

# Real skills: EHR feature engineering, class imbalance,
# sensitivity-first evaluation, clinical reasoning.
# This IS what healthcare ML interviews test.