Albumentations - Augmentasi Gambar Tingkat Lanjut
Daftar Isi
Pendahuluan
Augmentasi gambar adalah salah satu teknik regularisasi paling efektif dalam computer vision. Dengan memperbanyak dataset pelatihan secara artifisial menggunakan versi gambar yang telah ditransformasi, kita dapat meningkatkan kemampuan generalisasi model secara signifikan dan mengurangi overfitting.
Albumentations adalah pustaka augmentasi gambar yang cepat, fleksibel, dan kaya fitur yang dirancang untuk praktisi machine learning. Dibangun di atas OpenCV dan NumPy, pustaka ini menyediakan lebih dari 70 jenis transformasi augmentasi yang berbeda dan dioptimalkan untuk performa — seringkali 2-10 kali lebih cepat dibandingkan alternatif seperti torchvision atau imgaug.Keunggulan utama Albumentations:
- Kecepatan: Sangat dioptimalkan dengan backend OpenCV
- Kelengkapan: 70+ transformasi mencakup geometris, warna, cuaca, dan lainnya
- Fleksibilitas: Bekerja dengan gambar, mask, bounding box, dan keypoint secara bersamaan
- Integrasi: Kompatibel penuh dengan PyTorch, TensorFlow, dan framework lainnya
- Reprodusibilitas: Transformasi deterministik dengan kontrol seed
Dalam tutorial ini, Anda akan mempelajari cara membangun pipeline augmentasi berkualitas produksi, mengintegrasikannya ke dalam alur kerja deep learning, membuat transformasi kustom, dan mengukur performa.
Prasyarat
Sebelum memulai tutorial ini, Anda harus memiliki:
- Python 3.8 atau lebih tinggi
- Pemahaman dasar konsep computer vision
- Keakraban dengan PyTorch (untuk integrasi DataLoader)
- Pengalaman dengan dasar-dasar NumPy dan pemrosesan gambar
Instalasi dan Pengaturan
Instal Albumentations dan dependensinya:
# Instal albumentations dengan semua ekstra
pip install albumentations[all]
Atau instalasi minimal
pip install albumentations
Dependensi tambahan untuk tutorial ini
pip install torch torchvision matplotlib opencv-python-headless
Verifikasi instalasi:
import albumentations as A
import cv2
import numpy as np
print(f"Versi Albumentations: {A.version}")
Muat gambar sampel
image = cv2.imread("sampel.jpg")
image = cv2.cvtColor(image, cv2.COLORBGR2RGB)
print(f"Bentuk gambar: {image.shape}")
Memahami Pipeline Augmentasi
Albumentations menggunakan pendekatan pipeline deklaratif. Anda mendefinisikan urutan transformasi, masing-masing dengan probabilitas penerapan, kemudian melewatkan data Anda melalui pipeline tersebut.
import albumentations as A
import cv2
import numpy as np
Definisikan pipeline sederhana
transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.3),
A.Resize(height=256, width=256),
])
Muat dan transformasi gambar
image = cv2.imread("sampel.jpg")
image = cv2.cvtColor(image, cv2.COLORBGR2RGB)
Terapkan transformasi
result = transform(image=image)
augmentedimage = result["image"]
print(f"Bentuk asli: {image.shape}")
print(f"Bentuk setelah augmentasi: {augmentedimage.shape}")
Pipeline juga dapat menangani mask, bounding box, dan keypoint secara bersamaan:
# Pipeline dengan dukungan bounding box
transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomCrop(height=300, width=300, p=1.0),
A.Resize(height=256, width=256),
], bboxparams=A.BboxParams(
format='pascalvoc', # [xmin, ymin, xmax, ymax]
minvisibility=0.3, # Hapus box yang kehilangan >70% visibilitas
labelfields=['labelkelas']
))
Terapkan dengan bounding box
result = transform(
image=image,
bboxes=[[50, 60, 200, 300], [100, 150, 350, 400]],
labelkelas=["kucing", "anjing"]
)
gambaraugmentasi = result["image"]
bboxaugmentasi = result["bboxes"]
labelaugmentasi = result["labelkelas"]
Transformasi Geometris
Transformasi geometris memodifikasi struktur spasial dari sebuah gambar. Ini penting untuk mengajarkan model agar invarian terhadap posisi, skala, dan orientasi.
# Pipeline augmentasi geometris komprehensif
transformasigeometris = A.Compose([
# Flip
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.2),
# Rotasi dan affine
A.Rotate(limit=30, bordermode=cv2.BORDERREFLECT101, p=0.5),
A.Affine(
scale=(0.8, 1.2),
translatepercent={"x": (-0.1, 0.1), "y": (-0.1, 0.1)},
rotate=(-15, 15),
shear=(-10, 10),
p=0.5
),
# Distorsi elastis dan grid
A.ElasticTransform(
alpha=120,
sigma=120 0.05,
p=0.3
),
A.GridDistortion(numsteps=5, distortlimit=0.3, p=0.3),
A.OpticalDistortion(distortlimit=0.05, shiftlimit=0.05, p=0.3),
# Perspektif
A.Perspective(scale=(0.05, 0.1), p=0.3),
# Potong dan ubah ukuran
A.RandomResizedCrop(
size=(256, 256),
scale=(0.6, 1.0),
ratio=(0.75, 1.333),
p=0.5
),
])
Terapkan ke gambar dan mask secara bersamaan
result = transformasigeometris(image=image, mask=masksegmentasi)
gambaraug = result["image"]
maskaug = result["mask"]
Rotasi Aman untuk Deteksi Objek
Saat bekerja dengan bounding box, berhati-hatilah dengan rotasi besar:
# Transformasi geometris aman untuk tugas deteksi
transformasideteksiaman = A.Compose([
A.HorizontalFlip(p=0.5),
A.Rotate(limit=10, p=0.3), # Rotasi kecil saja
A.RandomResizedCrop(
size=(512, 512),
scale=(0.7, 1.0),
p=0.5
),
A.PadIfNeeded(minheight=512, minwidth=512, p=1.0),
], bboxparams=A.BboxParams(
format='coco', # [xmin, ymin, lebar, tinggi]
minarea=1024, # Hapus box lebih kecil dari 32x32
minvisibility=0.3,
labelfields=['idkategori']
))
Transformasi Warna
Augmentasi warna mengajarkan model agar tahan terhadap kondisi pencahayaan, pengaturan kamera, dan variasi warna yang berbeda.
transformasiwarna = A.Compose([
# Kecerahan dan kontras
A.RandomBrightnessContrast(
brightness
limit=0.2,
contrastlimit=0.2,
p=0.5
),
# Hue, saturasi, value
A.HueSaturationValue(
hueshiftlimit=20,
satshiftlimit=30,
valshiftlimit=20,
p=0.5
),
# Jitter warna
A.ColorJitter(
brightness=0.2,
contrast=0.2,
saturation=0.2,
hue=0.1,
p=0.3
),
# Manipulasi channel
A.ChannelShuffle(p=0.05),
A.RGBShift(rshiftlimit=15, gshiftlimit=15, bshiftlimit=15, p=0.3),
# Penyesuaian tone
A.CLAHE(cliplimit=4.0, tilegridsize=(8, 8), p=0.3),
A.Equalize(p=0.2),
A.Posterize(numbits=4, p=0.1),
# Koreksi gamma
A.RandomGamma(gammalimit=(80, 120), p=0.3),
# Konversi ke grayscale sesekali
A.ToGray(p=0.05),
])
result = transformasiwarna(image=image)
gambarwarnaaug = result["image"]
Augmentasi Warna Spesifik Domain
# Pencitraan medis: pergeseran warna halus
warnamedis = A.Compose([
A.RandomBrightnessContrast(brightnesslimit=0.1, contrastlimit=0.1, p=0.5),
A.CLAHE(cliplimit=2.0, p=0.3),
A.GaussianBlur(blurlimit=(3, 5), p=0.2),
])
Citra satelit: variasi warna kuat
warnasatelit = A.Compose([
A.RandomBrightnessContrast(brightnesslimit=0.3, contrastlimit=0.3, p=0.7),
A.HueSaturationValue(hueshiftlimit=30, satshiftlimit=40, p=0.5),
A.RandomGamma(gammalimit=(60, 140), p=0.5),
])
Efek Cuaca dan Lingkungan
Albumentations menyediakan transformasi simulasi cuaca yang realistis yang membantu model melakukan generalisasi terhadap kondisi lingkungan yang berbeda.
transformasicuaca = A.Compose([
A.OneOf([
# Efek hujan
A.RandomRain(
slant
lower=-10,
slantupper=10,
droplength=20,
dropwidth=1,
dropcolor=(200, 200, 200),
blurvalue=3,
brightnesscoefficient=0.7,
raintype="drizzle",
p=1.0
),
# Efek salju
A.RandomSnow(
snowpointlower=0.1,
snowpointupper=0.3,
brightnesscoeff=2.0,
p=1.0
),
# Efek kabut
A.RandomFog(
fogcoeflower=0.3,
fogcoefupper=0.5,
alphacoef=0.1,
p=1.0
),
# Silau matahari
A.RandomSunFlare(
flareroi=(0, 0, 1, 0.5),
anglelower=0,
angleupper=1,
numflarecircleslower=3,
numflarecirclesupper=6,
srcradius=200,
p=1.0
),
# Bayangan
A.RandomShadow(
shadowroi=(0, 0.5, 1, 1),
numshadowslower=1,
numshadowsupper=3,
shadowdimension=5,
p=1.0
),
], p=0.4),
# Noise (mensimulasikan noise sensor dalam kondisi buruk)
A.OneOf([
A.GaussNoise(varlimit=(10.0, 50.0), p=1.0),
A.ISONoise(colorshift=(0.01, 0.05), intensity=(0.1, 0.5), p=1.0),
A.MultiplicativeNoise(multiplier=(0.9, 1.1), p=1.0),
], p=0.3),
# Blur (mensimulasikan gerakan atau defokus)
A.OneOf([
A.MotionBlur(blurlimit=7, p=1.0),
A.GaussianBlur(blurlimit=7, p=1.0),
A.MedianBlur(blurlimit=5, p=1.0),
], p=0.2),
])
result = transformasicuaca(image=image)
gambarcuacaaug = result["image"]
Membangun Pipeline Kompleks dengan Compose
Albumentations menyediakan operator komposisi yang kuat untuk membangun pipeline yang canggih.
# Pipeline produksi lengkap menggabungkan semua kategori transformasi
pipelineproduksi = A.Compose([
# Transformasi level spasial (diterapkan pertama)
A.OneOf([
A.RandomResizedCrop(size=(384, 384), scale=(0.5, 1.0), p=1.0),
A.Compose([
A.Resize(height=420, width=420),
A.CenterCrop(height=384, width=384),
], p=1.0),
], p=1.0),
A.HorizontalFlip(p=0.5),
A.Rotate(limit=15, p=0.3),
# Transformasi level piksel
A.OneOf([
A.RandomBrightnessContrast(brightnesslimit=0.2, contrastlimit=0.2, p=1.0),
A.HueSaturationValue(hueshiftlimit=20, satshiftlimit=30, p=1.0),
A.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1, p=1.0),
], p=0.5),
# Efek cuaca (probabilitas rendah)
A.OneOf([
A.RandomRain(p=1.0),
A.RandomFog(p=1.0),
A.RandomShadow(p=1.0),
], p=0.1),
# Degradasi kualitas
A.OneOf([
A.GaussNoise(p=1.0),
A.GaussianBlur(blurlimit=5, p=1.0),
A.ImageCompression(qualitylower=60, qualityupper=90, p=1.0),
], p=0.2),
# Cutout / dropout (regularisasi)
A.CoarseDropout(
maxholes=8,
maxheight=32,
maxwidth=32,
minholes=1,
minheight=8,
minwidth=8,
fillvalue=0,
p=0.3
),
# Normalisasi untuk input model
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
])
Menggunakan ReplayCompose untuk Debugging
# ReplayCompose mencatat transformasi mana yang diterapkan
replaytransform = A.ReplayCompose([
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.5),
A.GaussNoise(p=0.3),
])
result = replaytransform(image=image)
augmented = result["image"]
replay = result["replay"]
Inspeksi apa yang diterapkan
for infotransform in replay["transforms"]:
nama = infotransform["_classfullname_"]
diterapkan = infotransform.get("applied", False)
print(f"{nama}: diterapkan={diterapkan}")
Integrasi dengan PyTorch DataLoader
Integrasi yang mulus dengan PyTorch adalah salah satu fitur terkuat Albumentations.
import torch
from torch.utils.data import Dataset, DataLoader
import albumentations as A
from albumentations.pytorch import ToTensorV2
import cv2
import os
class DatasetKlasifikasiGambar(Dataset):
"""Dataset kustom dengan augmentasi Albumentations."""
def init(self, dirgambar, label, transform=None):
self.dirgambar = dirgambar
self.filegambar = sorted(os.listdir(dirgambar))
self.label = label
self.transform = transform
def len(self):
return len(self.filegambar)
def getitem(self, idx):
# Muat gambar
pathgambar = os.path.join(self.dirgambar, self.filegambar[idx])
image = cv2.imread(pathgambar)
image = cv2.cvtColor(image, cv2.COLORBGR2RGB)
label = self.label[idx]
# Terapkan transformasi albumentations
if self.transform:
result = self.transform(image=image)
image = result["image"]
return image, label
Definisikan transformasi untuk pelatihan dan validasi
transformlatih = A.Compose([
A.RandomResizedCrop(size=(224, 224), scale=(0.6, 1.0)),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
], p=0.5),
A.GaussNoise(p=0.2),
A.CoarseDropout(maxholes=4, maxheight=28, maxwidth=28, p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])
transformval = A.Compose([
A.Resize(height=256, width=256),
A.CenterCrop(height=224, width=224),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])
Buat dataset dan dataloader
datasetlatih = DatasetKlasifikasiGambar(
dirgambar="/data/train",
label=labellatih,
transform=transformlatih,
)
datasetval = DatasetKlasifikasiGambar(
dirgambar="/data/val",
label=labelval,
transform=transformval,
)
loaderlatih = DataLoader(
datasetlatih,
batchsize=32,
shuffle=True,
numworkers=4,
pinmemory=True,
persistentworkers=True,
)
loaderval = DataLoader(
datasetval,
batchsize=64,
shuffle=False,
numworkers=4,
pinmemory=True,
)
Dataset Deteksi Objek dengan Bounding Box
class DatasetDeteksi(Dataset):
"""Dataset deteksi dengan dukungan augmentasi bounding box."""
def init(self, dirgambar, anotasi, transform=None):
self.dirgambar = dirgambar
self.anotasi = anotasi
self.transform = transform
def len(self):
return len(self.anotasi)
def getitem(self, idx):
ann = self.anotasi[idx]
image = cv2.imread(os.path.join(self.dirgambar, ann["namafile"]))
image = cv2.cvtColor(image, cv2.COLORBGR2RGB)
bboxes = ann["bboxes"] # Daftar [xmin, ymin, xmax, ymax]
label = ann["labelkelas"] # Daftar ID kelas
if self.transform:
result = self.transform(
image=image,
bboxes=bboxes,
labelkelas=label,
)
image = result["image"]
bboxes = result["bboxes"]
label = result["labelkelas"]
# Konversi ke tensor
bboxes = torch.tensor(bboxes, dtype=torch.float32)
label = torch.tensor(label, dtype=torch.int64)
target = {"boxes": bboxes, "labels": label}
return image, target
transformdeteksi = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomResizedCrop(size=(512, 512), scale=(0.5, 1.0)),
A.RandomBrightnessContrast(p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(),
], bboxparams=A.BboxParams(
format='pascalvoc',
minvisibility=0.3,
labelfields=['labelkelas'],
))
Transformasi Kustom
Anda dapat membuat transformasi augmentasi kustom dengan melakukan subclassing dari kelas dasar yang sesuai.
import albumentations as A
from albumentations.core.transformsinterface import ImageOnlyTransform, DualTransform
import numpy as np
import cv2
class NoisePerChannel(ImageOnlyTransform):
"""Menambahkan tingkat noise yang berbeda ke setiap channel."""
def init(self, rentangnoise=(5, 25), alwaysapply=False, p=0.5):
super().init(alwaysapply, p)
self.rentangnoise = rentangnoise
def apply(self, img, levelnoise=None, params):
if levelnoise is None:
return img
result = img.astype(np.float32)
for ch in range(img.shape[2]):
noise = np.random.normal(0, levelnoise[ch], img.shape[:2])
result[:, :, ch] += noise
return np.clip(result, 0, 255).astype(np.uint8)
def getparams(self):
levelnoise = [
np.random.uniform(self.rentangnoise[0], self.rentangnoise[1])
for in range(3)
]
return {"levelnoise": levelnoise}
def gettransforminitargsnames(self):
return ("rentangnoise",)
class GridMask(DualTransform):
"""Augmentasi GridMask: menutupi area dengan pola grid."""
def init(self, jumlahgrid=(3, 7), nilaiisi=0, rotasi=0,
alwaysapply=False, p=0.5):
super().init(alwaysapply, p)
self.jumlahgrid = jumlahgrid
self.nilaiisi = nilaiisi
self.rotasi = rotasi
def apply(self, img, arraymask=None, params):
if arraymask is None:
return img
result = img.copy()
result[arraymask == 0] = self.nilaiisi
return result
def applytomask(self, mask, arraymask=None, params):
return mask # Jangan terapkan grid ke mask segmentasi
def getparamsdependentontargets(self, params):
img = params["image"]
h, w = img.shape[:2]
jumlah = np.random.randint(self.jumlahgrid[0], self.jumlahgrid[1] + 1)
tinggisel = h // jumlah
lebarsel = w // jumlah
rasio = np.random.uniform(0.3, 0.7)
arraymask = np.ones((h, w), dtype=np.uint8)
for i in range(jumlah + 1):
for j in range(jumlah + 1):
y1 = int(i tinggisel)
x1 = int(j lebarsel)
y2 = min(int(y1 + tinggisel rasio), h)
x2 = min(int(x1 + lebarsel rasio), w)
arraymask[y1:y2, x1:x2] = 0
return {"arraymask": arraymask}
@property
def targetsasparams(self):
return ["image"]
def gettransforminitargsnames(self):
return ("jumlahgrid", "nilaiisi", "rotasi")
Gunakan transformasi kustom dalam pipeline
pipelinekustom = A.Compose([
A.HorizontalFlip(p=0.5),
NoisePerChannel(rentangnoise=(5, 20), p=0.3),
GridMask(jumlahgrid=(3, 6), p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
A/B Testing Strategi Augmentasi
Membandingkan strategi augmentasi secara sistematis sangat penting untuk memaksimalkan performa model.
import json
import time
from pathlib import Path
from collections import defaultdict
def buatstrategiaugmentasi():
"""Definisikan beberapa strategi augmentasi untuk A/B testing."""
strategi = {
"dasar": A.Compose([
A.Resize(height=224, width=224),
A.HorizontalFlip(p=0.5),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]),
"moderat": A.Compose([
A.RandomResizedCrop(size=(224, 224), scale=(0.7, 1.0)),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.3),
A.HueSaturationValue(p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]),
"agresif": A.Compose([
A.RandomResizedCrop(size=(224, 224), scale=(0.5, 1.0)),
A.HorizontalFlip(p=0.5),
A.Rotate(limit=20, p=0.4),
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.ColorJitter(p=1.0),
], p=0.6),
A.OneOf([
A.GaussNoise(p=1.0),
A.GaussianBlur(p=1.0),
], p=0.3),
A.CoarseDropout(maxholes=8, maxheight=28, maxwidth=28, p=0.4),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]),
"fokuscuaca": A.Compose([
A.RandomResizedCrop(size=(224, 224), scale=(0.6, 1.0)),
A.HorizontalFlip(p=0.5),
A.OneOf([
A.RandomRain(p=1.0),
A.RandomFog(p=1.0),
A.RandomSnow(p=1.0),
A.RandomShadow(p=1.0),
], p=0.4),
A.RandomBrightnessContrast(p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
]),
}
return strategi
def jalankanabtest(strategi, fnlatih, fnval, epoch=20):
"""Jalankan A/B test di berbagai strategi augmentasi."""
hasil = {}
for nama, transform in strategi.items():
print(f"\n{'='50}")
print(f"Menguji strategi: {nama}")
print(f"{'='50}")
datasetlatih = DatasetKlasifikasiGambar(
dirgambar="/data/train",
label=labellatih,
transform=transform,
)
loaderlatih = DataLoader(datasetlatih, batchsize=32, shuffle=True)
# Latih dan evaluasi
model = buatmodel()
riwayat = fnlatih(model, loaderlatih, epochs=epoch)
metrikval = fnval(model, loaderval)
hasil[nama] = {
"akurasival": metrikval["accuracy"],
"lossval": metrikval["loss"],
"riwayatpelatihan": riwayat,
}
print(f"Strategi '{nama}': akurasi={metrikval['accuracy']:.4f}")
# Laporkan hasil
print("\n\nRingkasan Hasil A/B Test:")
print("-" 50)
for nama, metrik in sorted(hasil.items(), key=lambda x: -x[1]["akurasival"]):
print(f" {nama:20s}: akurasi={metrik['akurasival']:.4f}, loss={metrik['lossval']:.4f}")
return hasil
Benchmark: Albumentations vs torchvision
Memahami perbedaan performa membantu membenarkan pemilihan Albumentations untuk produksi.
import time
import albumentations as A
from albumentations.pytorch import ToTensorV2
import torchvision.transforms as T
import numpy as np
from PIL import Image
import cv2
def benchmarkalbumentations(imagenp, jumlahiterasi=1000):
"""Benchmark pipeline Albumentations."""
transform = A.Compose([
A.RandomResizedCrop(size=(224, 224), scale=(0.5, 1.0)),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.5),
A.HueSaturationValue(p=0.5),
A.GaussNoise(p=0.3),
A.GaussianBlur(blurlimit=5, p=0.3),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])
# Pemanasan
for in range(10):
transform(image=imagenp)
mulai = time.perfcounter()
for in range(jumlahiterasi):
transform(image=imagenp)
durasi = time.perfcounter() - mulai
return durasi / jumlahiterasi
def benchmarktorchvision(imagepil, jumlahiterasi=1000):
"""Benchmark pipeline torchvision."""
transform = T.Compose([
T.RandomResizedCrop(224, scale=(0.5, 1.0)),
T.RandomHorizontalFlip(p=0.5),
T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
T.GaussianBlur(kernelsize=5),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
# Pemanasan
for in range(10):
transform(imagepil)
mulai = time.perfcounter()
for in range(jumlahiterasi):
transform(imagepil)
durasi = time.perfcounter() - mulai
return durasi / jumlahiterasi
Jalankan benchmark
imagenp = np.random.randint(0, 256, (512, 512, 3), dtype=np.uint8)
imagepil = Image.fromarray(imagenp)
waktualbu = benchmarkalbumentations(imagenp, jumlahiterasi=2000)
waktutv = benchmarktorchvision(imagepil, jumlahiterasi=2000)
print(f"Albumentations: {waktualbu1000:.2f} ms/gambar")
print(f"torchvision: {waktutv1000:.2f} ms/gambar")
print(f"Percepatan: {waktutv/waktualbu:.2f}x")
Hasil tipikal pada hardware modern:
Albumentations: ~1.2 ms/gambar
torchvision: ~3.5 ms/gambar
Percepatan: ~2.9x
Tabel Perbandingan Fitur
| Fitur | Albumentations | torchvision |
|------------------------------------|:--------------:|:-----------:|
| Jumlah transformasi | 70+ | ~25 |
| Dukungan bbox/keypoint | Ya | Terbatas |
| Efek cuaca | Ya | Tidak |
| Kelas dasar transformasi kustom | Ya | Ya |
| Kecepatan (relatif) | Cepat (1x) | Lebih lambat (2-3x)|
| Dukungan mask | Bawaan | Manual |
| Serialisasi (JSON/YAML) | Bawaan | Tidak |
| ReplayCompose | Ya | Tidak |
Praktik Terbaik
1. Urutkan Transformasi dengan Benar
# Urutan yang direkomendasikan:
1. Transformasi spasial (crop, resize, flip, rotate)
2. Transformasi level piksel (warna, noise, blur)
3. Transformasi dropout/cutout
4. Normalisasi
5. ToTensorV2 (jika menggunakan PyTorch)
2. Gunakan OneOf untuk Transformasi yang Saling Eksklusif
# Baik: hanya satu transformasi warna diterapkan per gambar
A.OneOf([
A.RandomBrightnessContrast(p=1.0),
A.HueSaturationValue(p=1.0),
A.ColorJitter(p=1.0),
], p=0.5)
3. Serialisasi Pipeline untuk Reprodusibilitas
import albumentations as A
import json
transform = A.Compose([
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.3),
])
Simpan ke JSON
terserialisasi = transform.todict()
with open("konfigurasiaugmentasi.json", "w") as f:
json.dump(terserialisasi, f, indent=2)
Muat dari JSON
with open("konfigurasiaugmentasi.json") as f:
config = json.load(f)
transformdimuat = A.fromdict(config)
4. Sesuaikan Kekuatan Augmentasi dengan Ukuran Dataset
# Dataset kecil (<1000 gambar): augmentasi agresif
Dataset sedang (1000-10000): augmentasi moderat
Dataset besar (>10000): augmentasi ringan
def dapatkantransformsesuaiukuran(ukurandataset, ukurangambar=224):
if ukurandataset < 1000:
return A.Compose([
A.RandomResizedCrop(size=(ukurangambar, ukurangambar), scale=(0.4, 1.0)),
A.HorizontalFlip(p=0.5),
A.Rotate(limit=30, p=0.5),
A.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.15, p=0.6),
A.GaussNoise(p=0.4),
A.CoarseDropout(maxholes=12, maxheight=32, maxwidth=32, p=0.5),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
A.pytorch.ToTensorV2(),
])
elif ukurandataset < 10000:
return A.Compose([
A.RandomResizedCrop(size=(ukurangambar, ukurangambar), scale=(0.6, 1.0)),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.3),
A.GaussNoise(p=0.2),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
A.pytorch.ToTensorV2(),
])
else:
return A.Compose([
A.RandomResizedCrop(size=(ukurangambar, ukurangambar), scale=(0.8, 1.0)),
A.HorizontalFlip(p=0.5),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
A.pytorch.ToTensorV2(),
])
5. Validasi Augmentasi Secara Visual
import matplotlib.pyplot as plt
def visualisasiaugmentasi(image, transform, jumlahsampel=8, kolom=4):
"""Tampilkan grid gambar augmentasi untuk inspeksi visual."""
baris = (jumlahsampel + kolom - 1) // kolom
fig, axes = plt.subplots(baris, kolom, figsize=(4 kolom, 4 baris))
for i, ax in enumerate(axes.flatten()):
if i == 0:
ax.imshow(image)
ax.settitle("Asli")
elif i <= jumlahsampel:
result = transform(image=image)
ax.imshow(result["image"])
ax.settitle(f"Aug {i}")
ax.axis("off")
plt.tightlayout()
plt.savefig("pratinjauaugmentasi.png", dpi=150)
plt.show()
Kesimpulan
Albumentations adalah pustaka yang kuat dan berperforma tinggi untuk augmentasi gambar dalam alur kerja machine learning. Dalam tutorial ini, Anda telah mempelajari cara:
- Membangun pipeline augmentasi dengan transformasi geometris, warna, dan cuaca
- Mengintegrasikan Albumentations dengan lancar ke PyTorch DataLoader
- Membuat transformasi kustom dengan melakukan subclassing dari kelas dasar
- Merancang dan menjalankan A/B test untuk membandingkan strategi augmentasi
- Membenchmark Albumentations terhadap torchvision dan memahami keuntungan performa
Kunci dari augmentasi yang efektif adalah mencocokkan strategi Anda dengan domain dan ukuran dataset yang spesifik. Mulailah dengan augmentasi moderat, visualisasikan hasilnya untuk memastikan terlihat realistis, dan uji secara sistematis berbagai strategi untuk menemukan yang paling cocok untuk tugas Anda.
Untuk bacaan lebih lanjut, periksa dokumentasi resmi Albumentations di albumentations.ai dan jelajahi daftar lengkap transformasi yang tersedia di pustaka tersebut.