Data Augmentation per Computer Vision: Tecniche e Best Practices
Uno dei problemi più comuni in computer vision è l'overfitting: il modello impara a memoria il training set invece di generalizzare. La soluzione più efficace è la data augmentation: l'applicazione di trasformazioni casuali alle immagini durante il training per aumentare artificialmente la varieta dei dati e insegnare al modello l'invarianza alle trasformazioni irrilevanti per il task.
Una strategia di augmentation ben progettata può valere quanto raddoppiare il dataset. Una strategia sbagliata può degradare le performance. In questo articolo vedremo le tecniche fondamentali con Albumentations (la libreria più potente) e torchvision.transforms, le tecniche avanzate come MixUp e CutMix, e come scegliere l'augmentation giusta per ogni dominio. Tratteremo anche come implementare pipeline personalizzate, misurare l'impatto reale di ogni trasformazione e deployare in produzione con il minimo overhead computazionale.
Cosa Imparerai
- perchè la data augmentation funziona: il principio dell'invarianza
- Albumentations vs torchvision: quando usare cosa
- Tecniche geometriche: flip, rotazione, crop, perspective transform
- Tecniche fotometriche: brightness, contrast, color jitter, CLAHE
- Tecniche avanzate: MixUp, CutMix, Mosaic, GridDistortion
- AutoAugment e RandAugment: ricerca automatica delle politiche
- Augmentation per detection e segmentazione (con coordinate e maschere)
- Domain-specific augmentation: medico, industriale, satellitare
- Come misurare l'efficacia dell'augmentation con ablation study
- Pipeline ottimizzata per training veloce e minimo overhead
1. perchè la Data Augmentation Funziona
La data augmentation si basa su un principio fondamentale: le trasformazioni che applichiamo non devono cambiare il significato semantico dell'immagine (l'output corretto del modello), ma devono cambiare i pixel in modo che il modello non possa semplicemente memorizzare i pattern superficiali.
Dal punto di vista della teoria dell'apprendimento, la data augmentation è una forma di regularizzazione implicita: amplia lo spazio delle trasformazioni rispetto alle quali vogliamo che il modello sia invariante. Se alleniamo con flip orizzontali, il modello apprende che il lato sinistro e il lato destro di un gatto non influenzano la classificazione. Se alleniamo con variazioni di luminosita, il modello impara a ignorare le condizioni di illuminazione.
Il Principio dell'Invarianza e l'Impatto Pratico
# Esempio: classificazione gatti/cani
# Trasformazioni CORRETTE (preservano la semantica):
# - Flip orizzontale: un gatto capovolto orizzontalmente è ancora un gatto ✓
# - Variazione luminosita: un gatto in penombra è ancora un gatto ✓
# - Crop random: un dettaglio del gatto è ancora riconoscibile come gatto ✓
# - Rotazione lieve: un gatto ruotato di 15 gradi è ancora un gatto ✓
# Trasformazioni PERICOLOSE (potrebbero cambiare la semantica):
# - Flip VERTICALE per traffico stradale: "stop" capovolto perde significato ✗
# - Rotazione >45 gradi per testo/numeri: "6" ruotato diventa "9" ✗
# - Scala estrema: un oggetto crop al 5% potrebbe perdere contesto ✗
# - Color jitter estremo su diagnostica medica: il colore è semanticamente rilevante ✗
# Regola d'oro:
# "Un'augmentation è valida se un umano, vedendo l'immagine aumentata,
# darebbe ancora la stessa label"
# Impatto pratico su benchmark (stesso modello ResNet-18, stessi iperparametri):
# CIFAR-10 senza augmentation: ~84.3% accuracy
# + Flip + Crop: ~91.8% accuracy (+7.5%)
# + Color Jitter: ~93.2% accuracy (+1.4%)
# + Cutout/CoarseDropout: ~94.1% accuracy (+0.9%)
# + MixUp (alpha=0.2): ~95.3% accuracy (+1.2%)
# + CutMix (alpha=1.0): ~95.8% accuracy (+0.5%)
# + AutoAugment (CIFAR-10 policy): ~97.1% accuracy (+1.3%)
# TrivialAugment + MixUp: ~97.4% accuracy (miglior combinazione)
# Nota: ogni +% è applicato sul modello SENZA aggiungere dati reali.
# Data augmentation = dataset virtualmente infinito da dati finiti.1.1 Tipi di Invarianza da Apprendere
Non tutte le applicazioni di computer vision richiedono le stesse invarianze. Prima di costruire la pipeline di augmentation, chiediamoci: da cosa vogliamo che il nostro modello sia robusto?
Mappa Invarianza-Trasformazione per Dominio
| Dominio | Invarianze utili | Invarianze PERICOLOSE |
|---|---|---|
| Foto naturali | Flip H, crop, luminosita, colore | Flip V, rotazione 90 gradi |
| Testo/OCR | Luminosita, rumore lieve | Rotazione, flip, distorsione |
| Traffico/Segnali | Luminosita, blur, crop | Flip V, rotazione 90 gradi |
| Radiografia (torace) | Flip H, rotazione lieve, contrasto | Flip V, color shift, rotazione forte |
| Istologia | Flip H/V, rotazione 90, color shift lieve | Rotazione elastica forte, scala estrema |
| Ispezione industriale | Rotazione 360, luminosita, blur, rumore | Scale molto estrema (perde dettaglio difetti) |
| Satellitare | Rotazione 90/180, flip H/V | Cambio colore forte (banda spettrale) |
2. Albumentations: La Libreria di Riferimento
Albumentations è la libreria di data augmentation più potente e flessibile per computer vision. A differenza di torchvision.transforms, supporta nativamente:
- Immagini + maschere di segmentazione (trasformazioni geometriche sincronizzate)
- Immagini + bounding boxes (coordinate aggiornate automaticamente)
- Immagini + keypoints (punti chiave mantenuti coerenti)
- Pipeline ottimizzate con OpenCV (più veloce di PIL del 15-40%)
- Più di 70 trasformazioni disponibili out-of-the-box
La sua architettura a pipeline è composabile: ogni trasformazione ha una probabilità
p di essere applicata, e trasformazioni come A.OneOf permettono
di campionare da un insieme di trasformazioni alternative. Questo crea uno spazio di
augmentation esponenzialmente grande con poche linee di codice.
Albumentations: Pipeline Completa per Classificazione
import albumentations as A
from albumentations.pytorch import ToTensorV2
import numpy as np
import cv2
# ---- Pipeline standard per classificazione ----
def get_classification_transforms(img_size: int = 224, is_train: bool = True):
if is_train:
return A.Compose([
# --- Geometriche ---
A.RandomResizedCrop(img_size, img_size, scale=(0.7, 1.0),
ratio=(0.75, 1.33), p=1.0),
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.15,
rotate_limit=15, border_mode=cv2.BORDER_REFLECT, p=0.7),
A.OneOf([
A.Perspective(scale=(0.05, 0.1)),
A.GridDistortion(num_steps=5, distort_limit=0.3),
A.ElasticTransform(alpha=1, sigma=50, alpha_affine=50)
], p=0.3),
# --- Fotometriche ---
A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, p=0.7),
A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30,
val_shift_limit=20, p=0.5),
A.OneOf([
A.GaussNoise(var_limit=(10, 50)),
A.GaussianBlur(blur_limit=(3, 7)),
A.MotionBlur(blur_limit=7),
A.MedianBlur(blur_limit=5)
], p=0.4),
A.ImageCompression(quality_lower=70, quality_upper=100, p=0.2),
# --- Dropout e occlusione ---
A.CoarseDropout(max_holes=8, max_height=32, max_width=32,
min_holes=1, p=0.3), # simile a Cutout
A.RandomGridShuffle(grid=(3, 3), p=0.1),
# --- Normalizzazione ImageNet ---
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
else:
# Validation: solo operazioni deterministiche
return A.Compose([
A.Resize(int(img_size * 1.14), int(img_size * 1.14)),
A.CenterCrop(img_size, img_size),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
Albumentations: Pipeline per Detection (BBox sincronizzate)
# ---- Pipeline per object detection (aggiorna bounding boxes!) ----
def get_detection_transforms(img_size: int = 640, is_train: bool = True):
if is_train:
return A.Compose([
A.RandomResizedCrop(img_size, img_size, scale=(0.5, 1.0)),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.7),
A.HueSaturationValue(p=0.5),
A.OneOf([
A.GaussNoise(),
A.GaussianBlur(blur_limit=3)
], p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
],
# CRITICO: specifica formato bbox per aggiornamento automatico
bbox_params=A.BboxParams(
format='yolo', # o 'pascal_voc', 'coco', 'albumentations'
label_fields=['class_labels'],
min_visibility=0.3, # rimuovi bbox se visibilità < 30%
min_area=100 # rimuovi bbox se area < 100 pixel
))
else:
return A.Compose([
A.Resize(img_size, img_size),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
],
bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))
# ---- Pipeline per segmentazione (aggiorna maschere!) ----
def get_segmentation_transforms(img_size: int = 512, is_train: bool = True):
if is_train:
return A.Compose([
A.RandomResizedCrop(img_size, img_size, scale=(0.7, 1.0)),
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1,
rotate_limit=10, p=0.5),
A.ElasticTransform(alpha=1, sigma=50, alpha_affine=50, p=0.3),
A.RandomBrightnessContrast(p=0.5),
A.GaussNoise(var_limit=(10, 30), p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
# NOTA: la maschera viene passata come argomento 'mask' - aggiornata automaticamente!
else:
return A.Compose([
A.Resize(img_size, img_size),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
# ---- Utilizzo con detection ----
transform = get_detection_transforms(is_train=True)
image = cv2.imread('image.jpg')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
bboxes = [(0.5, 0.5, 0.3, 0.4)] # formato YOLO [x_c, y_c, w, h]
labels = [0]
result = transform(image=image_rgb, bboxes=bboxes, class_labels=labels)
transformed_image = result['image'] # tensor [3, H, W]
transformed_boxes = result['bboxes'] # bbox aggiornate automaticamente!
print(f"Bbox originale: {bboxes} -> Bbox trasformata: {transformed_boxes}")2.1 Albumentations vs torchvision.transforms: Quando Usare Quale
Confronto Albumentations vs torchvision.transforms
| Caratteristica | Albumentations | torchvision.transforms |
|---|---|---|
| Supporto bbox/mask | Nativo e automatico | Solo immagini (nessun supporto) |
| Numero trasformazioni | 70+ trasformazioni | ~30 trasformazioni |
| Velocita | Molto veloce (OpenCV backend) | Più lento (PIL backend) |
| Integrazione PyTorch | ToTensorV2 necessario | Nativa |
| AutoAugment/RandAugment | Implementazione custom | Nativa in torchvision 0.12+ |
| Uso consigliato | Detection, segmentation, custom pipelines | Classificazione semplice, AutoAugment |
3. Tecniche Avanzate di Augmentation
3.1 MixUp: Interpolazione tra Immagini
MixUp (Zhang et al., 2018) mescola due immagini e le rispettive label con un coefficiente lambda campionato da una distribuzione Beta. Forza il modello a comportarsi linearmente tra le classi e riduce significativamente la fiducia nelle predizioni, migliorando la calibrazione e la robustezza. La loss deve essere calcolata come media pesata di due CrossEntropyLoss separate.
MixUp, CutMix e Mosaic da Zero
import torch
import numpy as np
def mixup_batch(images: torch.Tensor, labels: torch.Tensor,
alpha: float = 0.2) -> tuple:
"""
MixUp: interpola linearmente due immagini e le loro label.
Output: immagine mista, label miste (soft labels).
lambda ~ Beta(alpha, alpha)
image_mixed = lambda * image_a + (1 - lambda) * image_b
label_mixed = lambda * label_a + (1 - lambda) * label_b
Nota: con alpha=0.2, lambda e tipicamente vicino a 0 o 1 (quasi pura),
con alpha=1.0 (uniform Beta), le immagini sono equamente miscelate.
"""
batch_size = images.size(0)
lam = np.random.beta(alpha, alpha)
# Indici random per la seconda immagine nel batch
perm = torch.randperm(batch_size)
mixed_images = lam * images + (1 - lam) * images[perm]
labels_a = labels
labels_b = labels[perm]
# Per calcolo loss: loss = lam * CE(pred, a) + (1-lam) * CE(pred, b)
return mixed_images, labels_a, labels_b, lam
def cutmix_batch(images: torch.Tensor, labels: torch.Tensor,
alpha: float = 1.0) -> tuple:
"""
CutMix: sostituisce una regione rettangolare di un'immagine con quella di un'altra.
Più efficace di MixUp per task di detection (preserva regioni intatte).
lambda ~ Beta(alpha, alpha) # determina la proporzione dell'area tagliata
"""
batch_size, C, H, W = images.size()
lam = np.random.beta(alpha, alpha)
perm = torch.randperm(batch_size)
# Calcola dimensioni del box da tagliare
cut_ratio = np.sqrt(1 - lam)
cut_w = int(W * cut_ratio)
cut_h = int(H * cut_ratio)
# Centro del box random
cx = np.random.randint(W)
cy = np.random.randint(H)
# Coordinate box (clipped ai bordi)
x1 = np.clip(cx - cut_w // 2, 0, W)
x2 = np.clip(cx + cut_w // 2, 0, W)
y1 = np.clip(cy - cut_h // 2, 0, H)
y2 = np.clip(cy + cut_h // 2, 0, H)
# Applica CutMix (immutabile: crea una copia)
mixed_images = images.clone()
mixed_images[:, :, y1:y2, x1:x2] = images[perm, :, y1:y2, x1:x2]
# Ricalcola lambda effettivo basato sull'area reale del box
lam = 1 - (x2 - x1) * (y2 - y1) / (W * H)
return mixed_images, labels, labels[perm], lam
def mosaic_augmentation(images: list, labels: list) -> tuple:
"""
Mosaic augmentation (introdotto in YOLOv5):
Combina 4 immagini in un mosaico 2x2 con crop random centrale.
Particolarmente efficace per detection su oggetti piccoli:
ogni immagine nel mosaico e al 25% della dimensione originale,
simulando oggetti a distanza maggiore.
"""
assert len(images) == 4, "Mosaic richiede esattamente 4 immagini"
_, H, W = images[0].shape
mosaic = torch.zeros(3, H * 2, W * 2)
# Posiziona le 4 immagini nel mosaico
mosaic[:, 0:H, 0:W] = images[0] # top-left
mosaic[:, 0:H, W:2*W] = images[1] # top-right
mosaic[:, H:2*H, 0:W] = images[2] # bottom-left
mosaic[:, H:2*H, W:2*W] = images[3] # bottom-right
# Crop centrale random (simula diverse prospettive)
crop_y = np.random.randint(H // 2, H)
crop_x = np.random.randint(W // 2, W)
mosaic_cropped = mosaic[:, crop_y-H//2:crop_y+H//2,
crop_x-W//2:crop_x+W//2]
# In pratica i bbox vanno aggiornati di conseguenza (offset per posizione)
combined_labels = []
for i, lbl in enumerate(labels):
combined_labels.extend(lbl)
return mosaic_cropped, combined_labels
# ---- Training loop con MixUp/CutMix ----
def train_with_advanced_augmentation(
model, train_loader, optimizer, criterion, device,
mixup_alpha: float = 0.2, cutmix_alpha: float = 1.0,
mixup_prob: float = 0.5, cutmix_prob: float = 0.5
) -> float:
"""
Training step che applica MixUp o CutMix con probabilità data.
La scelta e esclusiva: se entrambe superano threshold, si usa la prima.
"""
model.train()
total_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
r = np.random.rand()
if r < mixup_prob:
mixed_images, labels_a, labels_b, lam = mixup_batch(images, labels, mixup_alpha)
outputs = model(mixed_images)
loss = lam * criterion(outputs, labels_a) + (1 - lam) * criterion(outputs, labels_b)
elif r < mixup_prob + cutmix_prob:
mixed_images, labels_a, labels_b, lam = cutmix_batch(images, labels, cutmix_alpha)
outputs = model(mixed_images)
loss = lam * criterion(outputs, labels_a) + (1 - lam) * criterion(outputs, labels_b)
else:
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad(set_to_none=True)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
total_loss += loss.item()
return total_loss / len(train_loader)3.2 AutoAugment, RandAugment e TrivialAugment
AutoAugment (Cubuk et al., 2019) usa reinforcement learning per cercare automaticamente la politica di augmentation ottimale su un dataset. Il problema: ricerca costosa (5000 GPU hours su CIFAR-10). RandAugment semplifica: applica N operazioni scelte casualmente tra una lista fissa con magnitude M uniforme, con solo 2 iperparametri da tuning. TrivialAugment va ancora oltre: 1 operazione random con magnitude random, spesso supera metodi più complessi.
AutoAugment, RandAugment e TrivialAugment con torchvision
from torchvision import transforms
MEAN = [0.485, 0.456, 0.406]
STD = [0.229, 0.224, 0.225]
# ---- AutoAugment (policy appresa su ImageNet) ----
train_auto = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.AutoAugment(
policy=transforms.AutoAugmentPolicy.IMAGENET, # o CIFAR10, SVHN
interpolation=transforms.InterpolationMode.BILINEAR
),
transforms.ToTensor(),
transforms.Normalize(mean=MEAN, std=STD)
])
# ---- RandAugment (N=2, M=9 sono i valori ottimali tipici) ----
train_rand = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandAugment(num_ops=2, magnitude=9),
transforms.ToTensor(),
transforms.Normalize(mean=MEAN, std=STD)
])
# ---- TrivialAugment: ancora più semplice, spesso meglio ----
# Seleziona 1 operazione casuale con magnitude casuale uniforme
train_trivial = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.TrivialAugmentWide(), # PyTorch 1.13+
transforms.ToTensor(),
transforms.Normalize(mean=MEAN, std=STD),
transforms.RandomErasing(p=0.1) # Aggiunge cutout
])
# ---- Augmentation Mix Strategy (raccomandato) ----
# TrivialAugment + MixUp/CutMix = la combinazione con il miglior rapporto
# semplicità/performance su quasi tutti i task di classificazione
# Non usare AutoAugment su dataset diversi da quello per cui e stata appresa
# (la policy di ImageNet non e ottimale per CIFAR-10 o per dataset medici)3.3 Augmentation Test-Time (TTA)
Il Test-Time Augmentation (TTA) applica le trasformazioni anche a inference time, eseguendo multiple predizioni sull'immagine aumentata e aggregando i risultati. Aumenta la robustezza senza richiedere retraining, a costo di N volte il tempo di inference.
Test-Time Augmentation (TTA) con PyTorch
import torch
import torch.nn.functional as F
import torchvision.transforms.functional as TF
@torch.no_grad()
def tta_predict(model: torch.nn.Module,
image: torch.Tensor, # [1, C, H, W]
n_augmentations: int = 5) -> torch.Tensor:
"""
Test-Time Augmentation: mediatura di predizioni su immagini aumentate.
Trucchi pratici:
- TTA di flip orizzontale e crop centrale sono le più affidabili
- Evitare TTA con rotazioni forti (possono degradare le performance)
- n=5 e un buon compromesso velocità/performance
"""
device = image.device
model.eval()
predictions = []
# 1. Immagine originale
pred = F.softmax(model(image), dim=1)
predictions.append(pred)
# 2. Flip orizzontale
flipped = TF.hflip(image)
pred = F.softmax(model(flipped), dim=1)
predictions.append(pred)
# 3. Flip verticale (solo se semanticamente valido)
# vflipped = TF.vflip(image)
# predictions.append(F.softmax(model(vflipped), dim=1))
# 4-N. Crop random dall'immagine scalata al 90%
_, C, H, W = image.shape
scale = 0.9
for _ in range(n_augmentations - 2):
# Scala lievemente
new_h, new_w = int(H * scale), int(W * scale)
resized = TF.resize(image, (new_h, new_w))
# Crop casuale alla dimensione originale
top = torch.randint(0, H - new_h + 1, (1,)).item()
left = torch.randint(0, W - new_w + 1, (1,)).item()
cropped = TF.crop(resized, top, left, new_h, new_w)
cropped = TF.resize(cropped, (H, W)) # rimetti a dimensione originale
pred = F.softmax(model(cropped), dim=1)
predictions.append(pred)
# Media delle probabilità (ensemble di N predizioni)
mean_pred = torch.stack(predictions).mean(dim=0)
return mean_pred.argmax(dim=1) # classe predetta4. Data Augmentation Domain-Specific
4.1 Medico: Preservare la Semantica Clinica
Le immagini mediche richiedono strategie di augmentation molto conservative. I canali colore portano informazione clinica (es. colorazione H&E nell'istologia), l'orientamento anatomico e rilevante (il flip verticale di una radiografia toracica e anatomicamente invalido) e le caratteristiche di rumore dipendono dal tipo di scanner. Consultare sempre un esperto di dominio prima di definire la pipeline.
Augmentation per Immagini Mediche per Modalità
import albumentations as A
from albumentations.pytorch import ToTensorV2
def get_medical_transforms(img_size: int = 512, modality: str = 'xray'):
"""
Pipeline augmentation per immagini mediche.
Diversa per modalità: radiografia, ecografia, risonanza, istologia.
"""
common = [
A.Resize(img_size, img_size),
]
if modality == 'xray':
augmentations = [
# Flip solo orizzontale (anatomicamente valido per torace)
A.HorizontalFlip(p=0.5),
# Rotazione lieve (paziente non sempre perfettamente allineato)
A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05,
rotate_limit=10, p=0.5),
# CLAHE migliora contrasto su radiografie
A.CLAHE(clip_limit=2.0, tile_grid_size=(8, 8), p=0.5),
# Rumore realistico del sensore
A.GaussNoise(var_limit=(5, 25), p=0.4),
# Variazione contrasto lieve
A.RandomGamma(gamma_limit=(80, 120), p=0.5),
# NON usare: flip verticale, color jitter, hue shift
]
elif modality == 'histology':
augmentations = [
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5), # OK per istologia (no orientamento fisso)
A.RandomRotate90(p=0.5),
# Variazione colore importante per istologia (diversi laboratori/staining)
A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20,
val_shift_limit=20, p=0.7),
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.7),
A.ElasticTransform(alpha=120, sigma=120 * 0.05,
alpha_affine=120 * 0.03, p=0.3),
]
elif modality == 'mri':
augmentations = [
A.HorizontalFlip(p=0.5),
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1,
rotate_limit=15, p=0.5),
# MRI: variazioni di intensità tra scanner diversi
A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, p=0.7),
# Simula artifact di movimento MRI
A.GaussianBlur(blur_limit=3, p=0.3),
# Elastic deformation anatomica realistica
A.ElasticTransform(alpha=1, sigma=50, alpha_affine=50, p=0.2),
]
else:
augmentations = []
norm = [
A.Normalize(mean=[0.5], std=[0.5]), # Grayscale normalization
# Per immagini RGB: A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
]
return A.Compose(common + augmentations + norm + [ToTensorV2()])4.2 Industriale: Robustezza alle Variazioni di Acquisizione
Augmentation per Visual Inspection Industriale
import albumentations as A
from albumentations.pytorch import ToTensorV2
def get_industrial_transforms(img_size: int = 256, is_train: bool = True):
"""
Pipeline per ispezione visiva industriale.
Obiettivo: robustezza a variazioni di illuminazione, rotazione parziale,
rumore del sensore e piccole deformazioni meccaniche.
"""
if is_train:
return A.Compose([
A.RandomResizedCrop(img_size, img_size, scale=(0.8, 1.0)),
# Rotazione: prodotti su nastro trasportatore hanno orientamenti variabili
A.RandomRotate90(p=0.5),
A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1,
rotate_limit=30, border_mode=0, p=0.7),
# Illuminazione: variazioni da illuminazione industriale (LED, fluorescente)
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.4, contrast_limit=0.4),
A.CLAHE(clip_limit=4.0),
A.RandomGamma(gamma_limit=(70, 130))
], p=0.8),
# Sensore: rumore e blur da sistemi di acquisizione industriali
A.OneOf([
A.GaussNoise(var_limit=(10, 60)),
A.ISONoise(color_shift=(0.01, 0.05), intensity=(0.1, 0.5)),
A.MultiplicativeNoise(multiplier=[0.9, 1.1]),
], p=0.4),
A.OneOf([
A.GaussianBlur(blur_limit=(3, 5)),
A.Defocus(radius=(1, 3)),
A.MotionBlur(blur_limit=5)
], p=0.3),
# Artefatti da riflessione/ombra
A.RandomShadow(shadow_roi=(0, 0, 1, 1), p=0.2),
A.Downscale(scale_min=0.7, scale_max=0.9, p=0.2), # simula bassa risoluzione
# CoarseDropout simula occlusione parziale del pezzo
A.CoarseDropout(max_holes=3, max_height=32, max_width=32, p=0.2),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
else:
return A.Compose([
A.Resize(img_size, img_size),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])4.3 Satellitare e Remote Sensing
Le immagini satellitari hanno proprietà uniche: orientamento rotationally invariant (nessun "su" e "giù" fisso), bande spettrali multiple (NIR, SWIR oltre all'RGB), e risoluzione spaziale molto variabile tra sensori diversi.
Augmentation per Immagini Satellitari Multi-banda
import albumentations as A
import numpy as np
def get_satellite_transforms(img_size: int = 256, n_bands: int = 4,
is_train: bool = True):
"""
Pipeline per immagini satellitari multi-banda.
n_bands: numero di bande spettrali (es. 3=RGB, 4=RGBI con NIR, 13=Sentinel-2)
"""
if is_train:
return A.Compose([
A.RandomCrop(img_size, img_size, p=1.0),
# Rotazione: immagini satellitari non hanno orientamento fisso
A.D4(p=1.0), # tutte le 8 simmetrie del quadrato (rotazioni 0/90/180/270 + flip)
# Shift/scale lieve per variazione di zoom/scala
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.15,
rotate_limit=45, border_mode=4, p=0.5),
# Variazioni radiometriche tra diverse scene e stagioni
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.6),
A.RandomGamma(gamma_limit=(80, 120), p=0.5),
# Rumore da sensore satellitare
A.GaussNoise(var_limit=(5, 30), p=0.3),
# Blur da risoluzione atmosferica
A.GaussianBlur(blur_limit=(3, 5), p=0.2),
# CloudDropout: simula copertura nuvolosa parziale
# (custom transform: riempie regioni con valori "cloud")
A.CoarseDropout(
max_holes=5, max_height=64, max_width=64,
fill_value=255, # bianco = nuvola
p=0.2
),
# Normalizzazione per multibanda (media/std per banda)
# Usa valori specifici del sensore, qui esempio per Sentinel-2 4 bande
A.Normalize(
mean=[0.485, 0.456, 0.406, 0.4], # 4 bande: R, G, B, NIR
std=[0.229, 0.224, 0.225, 0.22]
),
])
else:
return A.Compose([
A.CenterCrop(img_size, img_size),
A.Normalize(
mean=[0.485, 0.456, 0.406, 0.4],
std=[0.229, 0.224, 0.225, 0.22]
),
])5. Ablation Study: Come Misurare l'Efficacia dell'Augmentation
Prima di complicare la pipeline con trasformazioni avanzate, misurare sistematicamente l'impatto di ciascuna. Un ablation study sull'augmentation: stessa architettura, stesso scheduler, stessi hyperparametri di training - solo l'augmentation cambia.
Framework per Ablation Study dell'Augmentation
import torch
import albumentations as A
from albumentations.pytorch import ToTensorV2
from torchvision import datasets
import pandas as pd
def run_augmentation_ablation(
model_class,
dataset_path: str,
augmentation_configs: dict, # nome -> A.Compose
n_epochs: int = 30,
device: str = 'cuda'
) -> pd.DataFrame:
"""
Esegue ablation study sistematico su diverse configurazioni di augmentation.
Confronta tutte le configurazioni in condizioni identiche.
augmentation_configs = {
'baseline': A.Compose([A.Resize(224,224), A.Normalize(...), ToTensorV2()]),
'flip+crop': A.Compose([A.RandomResizedCrop(224,224), A.HorizontalFlip(0.5), ...]),
'flip+crop+col': A.Compose([..., A.ColorJitter(0.3,0.3,0.3), ...]),
'full_pipeline': get_classification_transforms(is_train=True),
}
"""
results = []
for config_name, transform in augmentation_configs.items():
print(f"\n=== Ablation: {config_name} ===")
# Dataset con questa specifica augmentation
train_dataset = datasets.ImageFolder(
f"{dataset_path}/train",
transform=lambda img: transform(image=np.array(img))['image']
)
val_dataset = datasets.ImageFolder(f"{dataset_path}/val",
transform=get_val_transform(224))
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=64, shuffle=True,
num_workers=4, pin_memory=True
)
val_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=128, shuffle=False, num_workers=4
)
# Modello fresco per ogni configurazione (stessi pesi iniziali!)
torch.manual_seed(42)
model = model_class(num_classes=len(train_dataset.classes)).to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=n_epochs)
criterion = torch.nn.CrossEntropyLoss()
best_val_acc = 0.0
for epoch in range(n_epochs):
# Training
model.train()
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
loss = criterion(model(images), labels)
optimizer.zero_grad(set_to_none=True)
loss.backward()
optimizer.step()
scheduler.step()
# Validation
model.eval()
correct = total = 0
with torch.no_grad():
for images, labels in val_loader:
images, labels = images.to(device), labels.to(device)
preds = model(images).argmax(1)
correct += preds.eq(labels).sum().item()
total += labels.size(0)
val_acc = 100.0 * correct / total
best_val_acc = max(best_val_acc, val_acc)
results.append({
'config': config_name,
'best_val_acc': round(best_val_acc, 2)
})
print(f"Best val accuracy: {best_val_acc:.2f}%")
df = pd.DataFrame(results).sort_values('best_val_acc', ascending=False)
print("\n=== Risultati Ablation Study ===")
print(df.to_string(index=False))
return dfImpatto della Data Augmentation su CIFAR-10 (ResNet-18)
| Configurazione Augmentation | Val Accuracy | Delta |
|---|---|---|
| Nessuna augmentation | 84.3% | - |
| Flip + Random Crop | 91.8% | +7.5% |
| + Color Jitter | 93.2% | +1.4% |
| + Cutout/CoarseDropout | 94.1% | +0.9% |
| + MixUp (alpha=0.2) | 95.3% | +1.2% |
| + CutMix (alpha=1.0) | 95.8% | +0.5% |
| AutoAugment (CIFAR-10 policy) | 97.1% | +1.3% |
| TrivialAugment + MixUp | 97.4% | +0.3% |
6. Errori Comuni e Best Practices
Errori Comuni nell'Augmentation
- Augmentation nel validation set: MAI applicare augmentation casuale nel validation o test set. Usa solo operazioni deterministiche (resize, normalize). Il val set serve per misurare la performance reale.
- Ignorare il dominio: Non usare Color Jitter per immagini in scala di grigi. Non usare flip verticale per immagini di testo. Non usare rotazione 90 gradi per scene naturali con orizzonte.
- Troppa augmentation: Una pipeline con 20 trasformazioni non e necessariamente meglio di una con 5 ben scelte. L'overfitting dell'augmentation e reale: il modello può imparare che le immagini aumentate sono diverse da quelle reali.
- Dimenticare la sincronizzazione: Per detection e segmentazione, le trasformazioni geometriche DEVONO essere applicate identicamente all'immagine e alle annotazioni. Albumentations lo fa automaticamente - torchvision.transforms no.
- Applicare CutMix/MixUp senza le loss corrette: Con soft labels (mix di classi), la CrossEntropyLoss standard va calcolata come media pesata. Non usare argmax sulle label per calcolare la loss.
- Non validare visivamente: Prima di addestrare, visualizza 20-30 immagini aumentate. Se sembrano "strane" anche a occhio umano, probabilmente sono troppo aggressive.
- Ignorare il batch size nell'augmentation: MixUp/CutMix richiedono batch size >= 2. Con batch size = 1 questi metodi non hanno senso.
Best Practices per Pipeline di Augmentation Ottimali
- Parti semplice, aggiungi complessità gradualmente: Inizia con Flip + RandomCrop. Aggiungi Color Jitter. Poi MixUp. Misura l'impatto ad ogni step con l'ablation study.
- Usa num_workers adeguato: L'augmentation avviene nei worker CPU. Con num_workers=4 e pin_memory=True, il preprocessing non e mai il bottleneck anche con pipeline complesse.
- Profile prima di ottimizzare: Usa torch.profiler o time.perf_counter per misurare il tempo effettivo del dataloader. Se e sotto il 10% del training step, l'augmentation non e il collo di bottiglia.
- Persisti le augmentazioni per grandi dataset: Per dataset molto grandi (100k+ immagini), pre-genera le versioni aumentate offline e salvale su disco. Questo riduce il compute real-time ma aumenta lo storage.
- Curriculum augmentation: Aumenta la magnitude dell'augmentation progressivamente durante il training. Inizia con augmentation leggera e diventa più aggressiva nelle ultime epoche.
Conclusioni
La data augmentation e uno degli strumenti più potenti e a basso costo per migliorare i modelli di computer vision. Con le tecniche giuste, e possibile ottenere incrementi di accuracy del 5-15% senza raccogliere un solo dato aggiuntivo. In questo articolo abbiamo visto:
- Il principio fondamentale: augmentation valida = trasformazione che preserva la semantica e invariante al task
- Albumentations come libreria di riferimento con supporto nativo per detection e segmentation con bbox/mask sincronizzate
- MixUp, CutMix e Mosaic: tecniche avanzate per guadagni di accuracy del 2-5% tramite interpolazione tra esempi
- AutoAugment, RandAugment e TrivialAugment: ricerca automatica della policy ottimale
- Test-Time Augmentation: miglioramento dell'inference senza retraining
- Augmentation domain-specific per medico, industriale e satellitare
- Come strutturare un ablation study per misurare l'impatto reale di ogni trasformazione
Navigazione Serie
- Precedente: Segmentazione: U-Net, Mask R-CNN e SAM
- Successivo: OpenCV e PyTorch: Pipeline Completa di Computer Vision