Implementasi Metode Konvolusi untuk Pemfilteran Gambar Menggunakan TensorFlow dan PyTorch

 

Implementasi Metode Konvolusi untuk Pemfilteran Gambar Menggunakan TensorFlow dan PyTorch

Oleh :

Warno Mulud

 

Abstrak

Pemfilteran gambar merupakan proses penting dalam pengolahan citra digital, digunakan untuk meningkatkan kualitas gambar, mengurangi noise, atau menonjolkan fitur tertentu. Dalam beberapa tahun terakhir, kemajuan teknologi deep learning memberikan pendekatan baru untuk pemfilteran gambar dengan memanfaatkan framework TensorFlow dan PyTorch. Artikel ini membahas konsep dasar pemfilteran gambar serta implementasinya menggunakan TensorFlow/PyTorch, dengan contoh sederhana penerapan filter konvolusi (kernel) untuk mempertajam (sharpening) dan meratakan (blurring) gambar.

Kata Kunci: Pemfilteran Gambar, Konvolusi, TensorFlow, PyTorch, Deep Learning.

Pendahuluan

Pengolahan citra digital memiliki peran yang semakin penting di berbagai bidang, seperti pengenalan wajah, pemantauan cuaca, analisis medis, hingga sistem keamanan. Salah satu tahapan dasar dalam pengolahan citra adalah pemfilteran gambar. Teknik ini digunakan untuk menghilangkan noise, memperbaiki tepi objek, atau menonjolkan pola tertentu pada gambar (Gonzalez & Woods, 2018; Jain, 1989).

Tradisionalnya, pemfilteran dilakukan menggunakan operasi konvolusi dengan kernel tertentu (misalnya Gaussian, Sobel, atau Laplacian) (Pratt, 2007). Namun, dengan berkembangnya deep learning, framework seperti TensorFlow dan PyTorch memungkinkan pemfilteran dilakukan secara lebih fleksibel, cepat, dan terintegrasi dengan pipeline pelatihan model neural network (Abadi et al., 2016; Paszke et al., 2019).

DASAR TEORI PEMFILTERAN GAMBAR

2.1. Pengolahan Citra Digital

Pengolahan citra digital adalah proses memanipulasi citra menggunakan teknik komputasi untuk memperbaiki kualitas visual, mengekstraksi informasi, atau mempersiapkan data untuk analisis lanjutan (Gonzalez & Woods, 2018). Citra digital direpresentasikan sebagai matriks dua dimensi yang berisi nilai intensitas atau warna pada setiap piksel. Operasi pengolahan dapat dilakukan di domain spasial maupun domain frekuensi.

Dalam domain spasial, transformasi dilakukan langsung pada nilai piksel citra melalui operasi seperti pemfilteran, konvolusi, dan morfologi. Sementara itu, pada domain frekuensi, citra ditransformasikan menggunakan transformasi Fourier, kemudian dimanipulasi berdasarkan frekuensi komponennya (Jain, 1989).

 

2.2. Konvolusi dalam Pengolahan Citra

Konvolusi merupakan operasi matematika penting dalam pengolahan citra yang digunakan untuk mengubah atau mengekstraksi fitur dari gambar. Operasi ini melibatkan sebuah kernel (atau filter), yaitu matriks kecil berukuran tetap (misalnya 3×3 atau 5×5), yang digeser ke seluruh piksel citra. Pada setiap posisi, nilai kernel dikalikan elemen-per-elemen dengan area citra yang bersesuaian, kemudian dijumlahkan untuk menghasilkan nilai piksel baru (Szeliski, 2022).

Secara umum, operasi konvolusi 2D dapat dituliskan sebagai:

dengan:

• : citra hasil konvolusi,
• : citra masukan,
• : kernel/filter,
• dan : setengah dari ukuran kernel.

Contoh kernel blur (low-pass filter 3×3):

Contoh kernel sharpen (high-pass filter):

Kernel blur digunakan untuk menghaluskan citra dan mengurangi noise, sedangkan kernel sharpen digunakan untuk mempertajam detail dan tepi citra.

 

2.3. Jenis-jenis Pemfilteran Gambar

Pemfilteran gambar secara umum dapat dibagi menjadi dua kelompok utama, yaitu low-pass filtering dan high-pass filtering, berdasarkan frekuensi komponen citra yang dilewatkan atau diredam (Gonzalez & Woods, 2018).

2.3.1. Low-Pass Filtering

Low-pass filtering adalah proses yang melewatkan komponen frekuensi rendah dan meredam komponen frekuensi tinggi. Komponen frekuensi rendah berkaitan dengan perubahan intensitas yang halus pada citra, sedangkan frekuensi tinggi mencerminkan detail atau noise. Low-pass filter sering digunakan untuk smoothing (penghalusan), noise reduction, dan efek blur (Jain, 1989).

Contoh kernel low-pass: average blur 3×3 (lihat persamaan ).

2.3.2. High-Pass Filtering

Sebaliknya, high-pass filtering melewatkan frekuensi tinggi dan meredam frekuensi rendah. Filter ini digunakan untuk penajaman citra dan pendeteksian tepi. High-pass filtering sangat berguna untuk menonjolkan kontur atau struktur pada citra, seperti pada deteksi tepi menggunakan Sobel, Prewitt, atau Laplacian operator (Szeliski, 2022).

Contoh kernel high-pass: sharpen (lihat persamaan ).

2.3.3. Kombinasi Low-pass dan High-pass

Dalam banyak kasus, kedua teknik ini digunakan secara kombinatif. Misalnya, citra difilter dengan low-pass terlebih dahulu untuk menghilangkan noise, kemudian high-pass diterapkan untuk menajamkan hasil. Pendekatan ini umum digunakan pada pengolahan citra medis, citra satelit, serta pra-pemrosesan data dalam deep learning (OpenCV, 2024).

2.3.4 Pemfilteran Gambar dengan TensorFlow dan PyTorch

Dalam era deep learning, pemfilteran citra tidak hanya dilakukan secara manual dengan kernel tetap, tetapi juga menggunakan operasi konvolusi dalam framework seperti TensorFlow dan PyTorch.
Kedua library ini menyediakan fungsi 2D convolution yang memungkinkan pengguna mendefinisikan kernel sendiri atau menggunakan kernel yang dipelajari dari data melalui pelatihan model (Goodfellow et al., 2016).

Contoh penerapan:

• TensorFlow: menggunakan tf.nn.conv2d() untuk mengaplikasikan kernel sharpening pada gambar RGB.
• PyTorch: menggunakan torch.nn.functional.conv2d() dengan kernel blur atau sharpen untuk menghasilkan citra yang terfilter.

Pendekatan ini mempercepat komputasi dan mudah diintegrasikan dengan pipeline deep learning untuk segmentasi, deteksi objek, atau peningkatan kualitas citra.

 

3. Metodologi

3.1. Perangkat dan Lingkungan

• Bahasa Pemrograman : Python 3.10
• Framework : TensorFlow 2.15 / PyTorch 2.x
• Library tambahan : OpenCV / Pillow, Matplotlib

3.2. Dataset

Gambar yang digunakan berupa citra RGB berformat .jpg. Dalam contoh ini digunakan gambar bebas lisensi dari dataset publik.

3.3. Langkah Implementasi

1. Membaca gambar dan mengubah ke tensor
2. Mendefinisikan kernel filter (blur atau sharpen)
3. Melakukan operasi konvolusi 2D menggunakan fungsi bawaan framework
4. Menampilkan hasil filter

 

Implementasi dengan TensorFlow :

import tensorflow as tf

import matplotlib.pyplot as plt

import cv2

import numpy as np

 

# 1. Baca gambar

img = cv2.imread('gambar_contoh.jpg')

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

img_tensor = tf.convert_to_tensor(img, dtype=tf.float32)

img_tensor = tf.expand_dims(img_tensor, axis=0)  # (1, H, W, C)

 

# 2. Definisi kernel sharpen

kernel = tf.constant([[0, -1, 0],

                      [-1, 5, -1],

                      [0, -1, 0]], dtype=tf.float32)

kernel = tf.reshape(kernel, [3, 3, 1, 1])

kernel = tf.repeat(kernel, repeats=3, axis=2)  # untuk RGB

 

# 3. Konvolusi

filtered = tf.nn.conv2d(img_tensor, kernel, strides=[1,1,1,1], padding='SAME')

 

# 4. Visualisasi

plt.figure(figsize=(10,5))

plt.subplot(1,2,1); plt.imshow(img); plt.title("Gambar Asli")

plt.subplot(1,2,2); plt.imshow(tf.cast(tf.clip_by_value(filtered[0],0,255), tf.uint8))

plt.title("Hasil Sharpening")

plt.show()

 

Implementasi dengan PyTorch :

import torch

import torch.nn.functional as F

from PIL import Image

import torchvision.transforms as T

import matplotlib.pyplot as plt

# 1. Baca dan ubah gambar

img = Image.open('gambar_contoh.jpg').convert('RGB')

transform = T.ToTensor()

img_tensor = transform(img).unsqueeze(0)  # (1, C, H, W)

# 2. Definisi kernel blur 3x3

kernel = torch.ones((3, 3)) / 9.0

kernel = kernel.view(1, 1, 3, 3)

kernel = kernel.repeat(3, 1, 1, 1)  # untuk 3 channel

# 3. Konvolusi

filtered = F.conv2d(img_tensor, kernel, padding=1, groups=3)

# 4. Visualisasi

plt.figure(figsize=(10,5))

plt.subplot(1,2,1); plt.imshow(img); plt.title("Gambar Asli")

plt.subplot(1,2,2); plt.imshow(filtered[0].permute(1,2,0).detach().numpy())

plt.title("Hasil Blur")

plt.show()

6. Hasil dan Pembahasan

Gambar 1. Hasil running Implementasi dengan TensorFlow

Gambar kiri adalah input awal menggunakan:

img = cv2.imread('gambar_contoh.jpg')

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Gambar ini masih dalam kondisi “apa adanya” dari kamera, tanpa perubahan kontras atau tepi (edge) yang diperjelas.

Gambar kanan adalah hasil setelah dikonvolusi dengan kernel sharpening menggunakan TensorFlow:

kernel = tf.constant([[0, -1, 0],

                      [-1, 5, -1],

                      [0, -1, 0]], dtype=tf.float32)

filtered = tf.nn.conv2d(img_tensor, kernel, strides=[1,1,1,1], padding='SAME')

Penjelasan Kernel

Kernel sharpening [ [0, -1, 0], [-1, 5, -1], [0, -1, 0] ] bekerja dengan cara:

• Nilai tengah (5) mempertahankan intensitas piksel asli.
• Nilai -1 di sekelilingnya mengurangi kontribusi piksel tetangga.
• Hasilnya: perubahan mendadak antar piksel (tepi) akan semakin kontras, sehingga detail tepi jadi lebih tajam.

Warna yang muncul tampak seperti filter “kuning–biru” karena:

·        matplotlib.pyplot.imshow() secara default akan menerapkan colormap “viridis” jika array tidak bertipe uint8 RGB yang valid.

·        Dalam kode ini, hasil filtered belum sepenuhnya dikonversi ke bentuk RGB standar sebelum ditampilkan.

Dampak Sharpening pada Citra

Tepi (edges) seperti kontur gedung, kendaraan, dan orang menjadi lebih tajam dan jelas. Area datar (seperti langit atau dinding polos) tidak berubah banyak. Proses ini banyak digunakan dalam: Enhancement foto (biar kelihatan lebih “tajam”), Pra-pemrosesan sebelum deteksi objek (supaya fitur tepi lebih terlihat oleh model ML/CV), Pengolahan citra satelit, medis, atau CCTV untuk mempertegas struktur.

 

Gambar 2. Hasil running Implementasi dengan PyTorch

Pada program ini dilakukan proses blurring (pengaburan citra) menggunakan framework deep learning PyTorch dengan metode konvolusi 2D. Proses dimulai dengan membaca citra RGB asli, kemudian citra tersebut dikonversi menjadi tensor PyTorch dengan bentuk [batch, channel, height, width] agar dapat diproses oleh layer konvolusi. Selanjutnya, diterapkan kernel blur berukuran 5×5 yang berisi nilai rata-rata (misalnya 1/25 untuk setiap elemen kernel), sehingga setiap piksel keluaran merupakan rata-rata dari piksel-piksel tetangga di sekitar posisi tersebut.

Hasilnya dapat dilihat pada gambar di atas:

Gambar kiri merupakan citra asli tanpa pengolahan.

Gambar kanan merupakan citra hasil blur.

Efek yang tampak adalah berkurangnya ketajaman tepi dan detail objek. Kontur bangunan, kendaraan, dan orang menjadi lebih halus, serta noise atau tekstur halus ikut berkurang. Proses ini bekerja mirip seperti low-pass filtering yang menghaluskan variasi intensitas tinggi pada gambar. Teknik ini sering digunakan sebagai tahapan pra-pemrosesan dalam sistem penglihatan komputer (computer vision) untuk mengurangi gangguan visual sebelum dilakukan analisis lanjutan seperti deteksi tepi atau segmentasi.

Dengan memanfaatkan PyTorch, proses konvolusi dapat dilakukan secara efisien dan fleksibel, sama seperti saat melatih model deep learning. Hal ini menunjukkan bahwa PyTorch tidak hanya cocok untuk pelatihan jaringan saraf, tetapi juga efektif untuk pengolahan citra dasar seperti blurring, sharpening, dan transformasi spasial lainnya

Implementasi menunjukkan bahwa framework deep learning dapat digunakan untuk operasi pemfilteran dasar dengan efisien. TensorFlow dan PyTorch memiliki fungsi konvolusi 2D teroptimasi yang berjalan cepat, bahkan pada GPU. Hasil sharpening menonjolkan detail tepi gambar, sedangkan filter blur menghaluskan citra dengan mengurangi noise berfrekuensi tinggi. Selain filter statis, TensorFlow/PyTorch juga dapat digunakan untuk learnable filters, misalnya dengan melatih convolutional layer agar kernel-nya belajar sendiri dari dataset, memberikan fleksibilitas yang jauh lebih besar daripada metode konvensional.

Kesimpulan

Dari dua percobaan program pengolahan citra yang telah dilakukan, baik menggunakan TensorFlow maupun PyTorch, dapat disimpulkan bahwa kedua framework memiliki kemampuan yang sama efektifnya dalam melakukan operasi dasar pengolahan citra, khususnya proses blurring.

Pada implementasi dengan TensorFlow, proses blur dilakukan dengan memanfaatkan operasi konvolusi 2D terhadap citra menggunakan kernel rata-rata (average filter). Proses ini menghasilkan citra yang lebih halus dengan detail objek yang berkurang, menandakan bahwa filter berhasil mereduksi komponen frekuensi tinggi (tepi dan tekstur halus).

Sementara itu, pada implementasi dengan PyTorch, proses serupa dilakukan dengan pendekatan tensor dan layer konvolusi. Hasil citra yang diperoleh menunjukkan efek blur yang konsisten dengan metode TensorFlow, di mana tepi-tepi objek menjadi lebih kabur dan noise visual berkurang.

Pemfilteran gambar menggunakan TensorFlow dan PyTorch memberikan pendekatan modern dan efisien dibandingkan metode tradisional. Dengan kemampuan GPU acceleration dan integrasi dengan pipeline deep learning, kedua framework ini sangat cocok untuk aplikasi pengolahan citra skala besar maupun eksperimen akademik.

 

REFERENSI

1. Abadi, M., Barham, P., Chen, J., Chen, Z., Davis, A., Dean, J., … Zheng, X. (2016). TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems. arXiv:1603.04467.
2. Gonzalez, R. C., & Woods, R. E. (2018). Digital Image Processing (4th ed.). Pearson.
3. Jain, A. K. (1989). Fundamentals of Digital Image Processing. Prentice-Hall.
4. Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., … Chintala, S. (2019). PyTorch: An Imperative Style, High-Performance Deep Learning Library. In Advances in Neural Information Processing Systems (pp. 8024–8035).
5. Pratt, W. K. (2007). Digital Image Processing: PIKS Scientific Inside (4th ed.). John Wiley & Sons.