Tutorial Albumentations: Advanced Image Augmentation untuk Computer Vision

# Albumentations - Augmentasi Gambar Tingkat Lanjut ## Daftar Isi 1. [Pendahuluan](#pendahuluan) 2. [Prasyarat](#prasyarat) 3. [Instalasi dan Pengaturan](#instalasi-dan-pengaturan) 4. [Memahami Pipe...

By Ruby Abdullah · · tutorial
AlbumentationsImage AugmentationComputer VisionData AugmentationPyTorchTraining

Albumentations - Augmentasi Gambar Tingkat Lanjut

Daftar Isi

  • Pendahuluan
  • Prasyarat
  • Instalasi dan Pengaturan
  • Memahami Pipeline Augmentasi
  • Transformasi Geometris
  • Transformasi Warna
  • Efek Cuaca dan Lingkungan
  • Membangun Pipeline Kompleks dengan Compose
  • Integrasi dengan PyTorch DataLoader
  • Transformasi Kustom
  • A/B Testing Strategi Augmentasi
  • Benchmark: Albumentations vs torchvision
  • Praktik Terbaik
  • Kesimpulan

  • 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(

    brightnesslimit=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(

    slantlower=-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.

    Artikel Terkait

    Tutorial Lengkap Keras 3: Framework Deep Learning Multi-Backend untuk TensorFlow, JAX, dan PyTorch

    Tutorial Lengkap Keras 3: Framework Deep Learning Multi-Backend untuk TensorFlow, JAX, dan PyTorch Keras 3 adalah evolus...

    Tutorial bitsandbytes: Kuantisasi 4-bit dan 8-bit untuk Large Language Models

    Tutorial bitsandbytes: Kuantisasi 4-bit dan 8-bit untuk Large Language Models Menjalankan Large Language Model (LLM) sep...

    Tutorial Liger Kernel: Efisiensi Training LLM dengan Triton Kernels

    Tutorial Lengkap Liger Kernel: Efisiensi Training LLM dengan Triton Kernels Penulis: Ruby Abdullah — PT RUBYTHALIB DATA ...

    Tutorial Lengkap FiftyOne by Voxel51: Tool Open-Source untuk Dataset dan Model Computer Vision

    Tutorial Lengkap FiftyOne by Voxel51: Tool Open-Source untuk Dataset dan Model Computer Vision Penulis: Ruby Abdullah Ta...