Pooling Layer CNN Pengertian, Fungsi, dan Jenisnya

Convolutional Neural Networks (CNN) telah merevolusi bidang deep learning, khususnya dalam tugas-tugas yang berkaitan dengan pengolahan citra dan video. CNN mampu secara otomatis mempelajari fitur-fitur penting dari data masukan, tanpa perlu feature engineering manual yang rumit. Salah satu komponen kunci dalam arsitektur CNN yang memungkinkan hal ini adalah pooling layer. Artikel ini akan membahas secara mendalam tentang pooling layer, mulai dari definisi, fungsi, jenis-jenis, hingga contoh implementasinya dalam kode Python menggunakan TensorFlow dan PyTorch.

Apa Itu Pooling Layer?

Pooling layer adalah salah satu blok bangunan dasar dalam Convolutional Neural Networks (CNN). Secara formal, pooling layer adalah operasi downsampling non-linear yang mengurangi dimensi spasial (lebar dan tinggi) dari feature map yang dihasilkan oleh convolutional layer sebelumnya. Proses ini mirip dengan memperkecil ukuran gambar, di mana detail-detail halus mungkin hilang, tetapi informasi penting tetap dipertahankan.

Dengan kata lain, pooling layer mengambil feature map sebagai input dan menghasilkan feature map baru yang lebih kecil. Proses ini dilakukan dengan menerapkan fungsi agregasi (seperti maksimum atau rata-rata) pada area-area kecil yang tumpang tindih (disebut kernel atau filter) pada feature map input.

Baca juga: Panduan Lengkap Convolutional Neural Networks (CNN) untuk Pemula

Fungsi Utama Pooling Layer

Pooling layer memiliki beberapa fungsi utama yang sangat penting dalam arsitektur CNN.

Reduksi Dimensi

Pooling layer secara signifikan mengurangi ukuran feature map. Misalnya, jika kita memiliki feature map berukuran 12×12 dan menggunakan pooling layer dengan kernel 2×2 dan stride 2, maka feature map hasil akan berukuran 6×6. Reduksi dimensi ini memiliki dua manfaat utama:

1. Mengurangi Beban Komputasi: Dengan feature map yang lebih kecil, jumlah parameter yang perlu dipelajari oleh CNN juga berkurang. Ini mempercepat proses pelatihan dan mengurangi kebutuhan sumber daya komputasi.
2. Mencegah Overfitting: Overfitting terjadi ketika model terlalu “hafal” data pelatihan dan tidak mampu melakukan generalisasi dengan baik pada data baru. Dengan mengurangi dimensi, pooling layer membantu mencegah overfitting dengan memaksa model untuk fokus pada fitur-fitur yang paling penting.

Invariansi Translasi (dan Sedikit Rotasi/Skala)

Pooling layer memberikan tingkat invariansi terhadap translasi (pergeseran) kecil pada objek dalam gambar. Artinya, jika suatu objek dalam gambar sedikit bergeser, pooling layer akan tetap menghasilkan feature map yang relatif sama. Hal ini penting karena dalam dunia nyata, posisi objek dalam gambar bisa bervariasi.

Ekstraksi Fitur Dominan

Dengan memilih nilai maksimum (pada max pooling) atau rata-rata (pada average pooling) dalam suatu area, pooling layer membantu mengekstraksi fitur-fitur yang paling dominan atau representatif dari feature map. Ini membantu CNN untuk fokus pada informasi yang paling penting dan mengabaikan detail-detail yang kurang relevan.

Jenis-Jenis Pooling Layer

Ada beberapa jenis pooling layer yang umum digunakan dalam CNN, masing-masing dengan cara kerja dan karakteristik yang berbeda:

Max Pooling

Max pooling adalah jenis pooling layer yang paling umum digunakan. Cara kerjanya adalah dengan memilih nilai maksimum dari setiap area kernel pada feature map. Misalnya, jika kita menggunakan kernel 2×2, maka max pooling akan memilih nilai piksel terbesar dari setiap blok 2×2 pada feature map input.

Feature Map:
[[1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 10, 11, 12],
 [13, 14, 15, 16]]

Max Pooling (kernel 2x2, stride 2):
[[6, 8],
 [14, 16]]

Max pooling efektif dalam mengekstraksi fitur-fitur yang kuat dan menonjol, seperti tepi (edges) atau sudut (corners) pada gambar. Kelebihan Max pooling adalah kemampuanya mempertahankan fitur yang paling menonjol, namun dapat menghilangkan informasi detail halus.

Average Pooling

Average pooling bekerja dengan cara menghitung nilai rata-rata dari setiap area kernel pada feature map.

Feature Map:
[[1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 10, 11, 12],
 [13, 14, 15, 16]]

Average Pooling (kernel 2x2, stride 2):
[[3.5, 5.5],
 [11.5, 13.5]]

Average pooling cenderung lebih “halus” daripada max pooling, karena mempertimbangkan semua nilai dalam area kernel. Ini bisa berguna ketika informasi dari seluruh area penting, seperti dalam kasus di mana kita ingin mempertahankan informasi tekstur. Kelebihan average pooling adalah kemampuannya mempertahankan informasi yang lebih lengkap dari suatu area. Namun, lebih rentan terhadap noise.

Parameter penting dalam max pooling dan average pooling meliputi:

• Kernel Size: Ukuran area yang digunakan untuk melakukan pooling (misalnya, 2×2, 3×3).
• Stride: Jarak pergeseran kernel pada feature map (misalnya, 1, 2). Stride 2 berarti kernel bergeser 2 piksel ke kanan atau ke bawah pada setiap langkah.
• Padding: Apakah menambahkan piksel tambahan (biasanya bernilai 0) di sekeliling feature map sebelum melakukan pooling. Padding dapat membantu mempertahankan informasi di tepi feature map.

Global Average Pooling (GAP)

Global Average Pooling (GAP) adalah kasus khusus dari average pooling di mana ukuran kernel sama dengan ukuran feature map itu sendiri. Dengan kata lain, GAP menghitung nilai rata-rata dari seluruh feature map, menghasilkan satu nilai tunggal untuk setiap feature map.

Feature Map:
[[1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 10, 11, 12],
 [13, 14, 15, 16]]

Global Average Pooling:
[8.5]

GAP memiliki beberapa keunggulan:

• Reduksi Parameter yang Signifikan: GAP menggantikan fully connected layer (yang biasanya memiliki banyak parameter) dengan satu nilai tunggal per feature map. Ini secara drastis mengurangi jumlah parameter dalam model, mengurangi risiko overfitting.
• Interpretasi yang Lebih Baik: Setiap nilai output dari GAP dapat diinterpretasikan sebagai tingkat aktivasi dari feature map yang bersangkutan. Ini membuat model lebih mudah dipahami.
• Sering digunakan untuk Klasifikasi: Dalam tugas klasifikasi gambar, GAP sering digunakan sebelum layer klasifikasi akhir (softmax). Setiap nilai output GAP dapat dikaitkan dengan probabilitas suatu kelas.

Penggunaan GAP seringkali lebih baik daripada flatten (mengubah feature map menjadi vektor 1D) sebelum fully connected layer, terutama karena GAP mengurangi jumlah parameter secara signifikan dan lebih tahan terhadap overfitting.

Jenis Lain (Opsional)

Selain ketiga jenis pooling layer di atas, ada beberapa jenis lain yang kurang umum digunakan, seperti:

• L2 Pooling: Menghitung akar kuadrat dari jumlah kuadrat nilai dalam area kernel.
• Stochastic Pooling: Memilih nilai secara acak dalam area kernel berdasarkan distribusi probabilitas.

Perbandingan Max Pooling dan Average Pooling

Pemilihan antara max pooling dan average pooling bergantung pada tugas dan jenis data yang dihadapi. Tidak ada aturan baku yang menentukan mana yang lebih baik. Seringkali, perlu dilakukan eksperimen untuk menentukan jenis pooling layer yang paling cocok untuk suatu kasus tertentu. Stride dan padding juga mempengaruhi hasil pooling, jadi penting untuk memilih nilai yang tepat untuk parameter ini.

Baca juga: Cara Kerja Filter CNN: Panduan Lengkap & Visualisasi

Contoh Implementasi Pooling Layer dengan Python

Berikut adalah contoh implementasi pooling layer dengan TensorFlow/Keras dan PyTorch:

Dengan TensorFlow/Keras

import tensorflow as tf
from tensorflow.keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D, Flatten, Dense

# Model dengan Max Pooling
model_max = tf.keras.Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)), # Kernel 2x2, stride default = kernel size
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(10, activation='softmax')
])

print("Model dengan Max Pooling")
model_max.summary()

# Model dengan Average Pooling
model_avg = tf.keras.Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    AveragePooling2D((2, 2)), # Kernel 2x2, stride default = kernel size
    Conv2D(64, (3, 3), activation='relu'),
    AveragePooling2D((2, 2)),
    Flatten(),
    Dense(10, activation='softmax')
])

print("\nModel dengan Average Pooling")
model_avg.summary()

# Model dengan Global Average Pooling
model_gap = tf.keras.Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    Conv2D(64, (3, 3), activation='relu'),
    GlobalAveragePooling2D(), # Tidak perlu kernel size dan stride
    Dense(10, activation='softmax')
])

print("\nModel dengan Global Average Pooling")
model_gap.summary()

Dengan PyTorch

import torch
import torch.nn as nn
import torch.nn.functional as F

class CNN_Max(nn.Module):
    def __init__(self):
        super(CNN_Max, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc = nn.Linear(64 * 5 * 5, 10) # Sesuaikan ukuran input sesuai output conv layer

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool1(x)
        x = F.relu(self.conv2(x))
        x = self.pool2(x)
        x = torch.flatten(x, 1) # Flatten dari dimensi 1
        x = self.fc(x)
        return F.softmax(x, dim=1)

class CNN_Avg(nn.Module):
    def __init__(self):
        super(CNN_Avg, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2)
        self.fc = nn.Linear(64 * 5 * 5, 10) # Sesuaikan ukuran input

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool1(x)
        x = F.relu(self.conv2(x))
        x = self.pool2(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return F.softmax(x, dim=1)
        
class CNN_GAP(nn.Module):
    def __init__(self):
      super(CNN_GAP,self).__init__()
      self.conv1 = nn.Conv2d(1,32, kernel_size=3)
      self.conv2 = nn.Conv2d(32,64,kernel_size=3)
      self.gap = nn.AdaptiveAvgPool2d((1,1)) #GAP
      self.fc = nn.Linear(64,10)

    def forward(self,x):
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = self.gap(x)
        x = torch.flatten(x,1)
        x = self.fc(x)
        return F.softmax(x, dim=1)


model_max_pt = CNN_Max()
print("Model dengan Max Pooling (PyTorch)")
print(model_max_pt)

model_avg_pt = CNN_Avg()
print("\nModel dengan Average Pooling (PyTorch)")
print(model_avg_pt)

model_gap_pt = CNN_GAP()
print("\nModel dengan Global Average Pooling (PyTorch)")
print(model_gap_pt)

Baca juga: Panduan Praktis Klasifikasi Gambar dengan TensorFlow dan Keras

Kesimpulan

Pooling layer adalah komponen krusial dalam arsitektur Convolutional Neural Networks (CNN). Pooling layer berfungsi untuk mereduksi dimensi feature map, memberikan invariansi terhadap translasi kecil, dan mengekstraksi fitur-fitur yang dominan. Ada berbagai jenis pooling layer, dengan max pooling, average pooling, dan global average pooling menjadi yang paling umum digunakan. Pemilihan jenis pooling layer yang tepat, serta parameter-parameternya (kernel size, stride, padding), bergantung pada tugas dan data yang dihadapi.

Kirim.ai hadir sebagai solusi digital berbasis AI yang dirancang untuk membantu bisnis Anda berkembang. Dengan platform SaaS yang dilengkapi berbagai alat AI canggih, termasuk AI Agent untuk optimasi SEO otomatis, Kirim.ai menawarkan solusi lengkap. Tidak hanya itu, Kirim.ai juga menyediakan layanan pengembangan platform yang komprehensif, strategi pemasaran digital, dan pembuatan konten visual. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu Anda.