1

Pengumuman Penting dari Jo-Pink

Halo The Next Digital Talents!

Modul Artificial Intelligence ini memang

sengaja Jo-Pink kasih full pack theory &
application dengan materi yang ‘rich’
banget.

Mengapa?
Supaya bisa tetap dipelajari setelah lulus dari program Data
Science & Artificial Intelligence Startup Campus!

Tapi ini banyak banget, gimana belajarnya?

Teman-teman bisa fokus mempelajari learning video sambil
membaca modul bagian use case atau aplikasinya ya.

Kalau ada yang tidak dipahami di learning

video, modul ini akan berperan jadi
‘ensiklopedia’ untuk mengusut tuntas
kebingunganmu.

Selamat belajar!
2
 Daftar Isi
A. Pengenalan Computer Vision (4)
B. Apa itu Gambar? (4)
C. Gambar Analog (5)
D. Gambar Digital (7)
■ Konsep (7)
■ Apa itu Pixel? (8)
■ Format Gambar Digital (9)
■ JPEG atau JPG (9)
■ PNG (10)
■ GIF (10)
■ TIFF (11)
■ EPS (11)
E. Computer Vision (14)
■ Image Processing (16)
F. Istilah pada Computer Vision (18)
■ Channel (18)
■ Kernel (19)
G. Permasalahan Utama Computer Vision (19)
H. OpenCV (24)
I. Scikit Image (25)
J. Fungsi Dasar OpenCV (26)
■ Membaca dan Menulis kembali Gambar (26)
■ Mengubah Warna pada Gambar (30)
■ Mengubah Ukuran Gambar (33)
■ Mengubah Lokasi Gambar (34)
■ Memutar Gambar (Rotasi) (35)
■ Image Thresholding (38)
■ Image Blurring dan Image Smoothing (42)
■ Image Enhancement (50) 3
 Daftar Isi
K. Object Detection (60)
a. Template Matching (61)
b. Corner Detection (64)
c. Edge Detection (68)
d. Grid Detection (80)
e. Contour Detection (83)
f. Feature Matching (91)
g. Watershed Algorithm (103)
h. Face Detection (116)
L. Computer Vision dengan Deep Learning (130)
a. Convolutional Neural Network (CNN) (130)
i. Studi Kasus - Menggunakan ANN pada data MNIST (140)
ii. Studi Kasus - Menggunakan CNN pada data MNIST (153)
iii. Studi Kasus - Menggunakan CNN pada gambar RGB (164)
b. Generative Adversarial Network (GAN) (176)
i. Studi Kasus - Menggunakan GAN pada data MNIST (178)
c. Deep Convolutional Generative Adversarial Network (DCGAN) (187)
d. You Only Look Once (YOLO) (195)
i. Studi Kasus - Menggunakan YOLO dengan COCO (198)
M. Kesimpulan (206)
N. Exercise (207)

4
 Pengenalan Computer Vision
Apa itu Gambar ?
Kita sehari - hari pasti sudah pernah mengetahui dan melihat sebuah gambar. Rasanya dalam
kehidupan manusia umumnya, tidak mungkin bahwa seseorang tidak pernah melihat sebuah
gambar, baik secara lukisan fisik ataupun dalam bentuk digital. Gambar merupakan salah satu seni
yang dapat dikatakan melekat dalam diri manusia dan merupakan salah satu aspek seni juga.
Gambar sendiri merupakan sebuah representasi visual dari sebuah objek, baik berupa bentuk
fisik seperti lukisan, gambar tangan, ataupun berbentuk media cetak, maupun representasi visual
dari bentuk digital dalam format dua dimensi. Sebuah gambar bisa dibuat dengan teknik fotografi,
seni digital, dan teknologi apapun yang dapat memproduksi sebuah gambar. Sebuah gambar dapat
disebut sebagai gambar analog dan juga gambar digital. Berikut perbedaan yang mencolok dari
kedua jenis gambar tersebut.

5
 Gambar tersebut merupakan sebuah gambar pemandangan sebuah gunung. Yang membedakan
adalah gambar tersebut terbagi menjadi dua macam exposure, dimana yang sebelah kiri merupakan
gambar analog, dan sebelah kanan merupakan gambar digital. Secara visual, kita dapat membedakan
dengan jelas bahwa gambar analog akan memiliki tingkat cahaya yang lebih baik dan kontras yang
lebih bagus. Gambar digital tidak akan memiliki warna dan cahaya yang sebagus pada gambar analog.
Akan tetapi, keduanya memiliki kelemahan masing - masing, dimana apabila gambar analog kita
besarkan, resolusi gambar kemungkinan akan pecah dan mengakibatkan gambar yang blur.
Sedangkan pada gambar digital, kita mungkin perlu melakukan beberapa proses tertentu untuk
mendapatkan gambar yang serupa.
Kedua bentuk gambar tersebut memiliki kelemahan dan kelebihannya masing - masing. Bagi
orang yang memiliki kecintaan terhadap fotografi akan lebih memilih untuk menghasilkan gambar
analog dibandingkan gambar digital, karena bagi sebagian besar orang, gambar analog dapat
dikategorikan sebagai sebuah seni fotografi yang tidak bisa direplikasi dengan teknologi. Bagi
sebagian orang juga, mungkin banyak yang menyukai gambar digital karena gambar digital
cenderung dapat disimpan lama dan mudah untuk disesuaikan dengan keinginan, karena orang hanya
perlu untuk mengambil gambar apa adanya, lalu akan disesuaikan dengan selera saat melakukan
proses pengeditan gambar.
Berdasarkan apa yang telah kita bahas, kita akan membahas gambar analog dan gambar digital
terlebih dahulu, agar kita lebih mengenal perbedaan keduanya dan mengetahui kelebihan dan
kekurangan dari masing - masing gambar tersebut.

Gambar Analog
Gambar Analog merupakan sebuah gambar yang sehari - hari kita lihat. Warna dan tingkat
kecerahannya menyerupai dengan apa yang dilihat oleh mata manusia. Gambar jenis ini umumnya
dapat kita temukan pada hasil fotografi, layar TV, lukisan, film rekaman, dan hal lainnya yang dapat
menampilkan gambar visual. Gambar analog tersebut memiliki tingkat kecerahan dan warna yang
baik dikarenakan spektrum warna pada gambar tersebut bersifat continuous.

6
 Kebanyakan gambar analog terbentuk karena adanya paparan sebuah film fotografi, yang
memiliki beberapa kandungan bahan kimia didalamnya dengan cahaya, menyebabkan timbulnya
sebuah reaksi kimia yang menyebabkan sebuah momen tertangkap pada film fotografi tersebut. Film
tersebut kemudian diproses lebih lanjut menggunakan bahan kimia lainnya agar dapat menghasilkan
sebuah gambar fisik dari momen tersebut. Karena menggunakan pemaparan cahaya, maka sifat warna
pada gambar tersebut bersifat continuous, karena kita tahu spektrum cahaya bersifat continuous
(mengambil referensi dari ilmu fisika).
Gambar analog menjadi terkenal karena umumnya sering digunakan sebagai ajang untuk
memperlihatkan sebuah seni fotografi. Banyak pecinta foto artistik yang menggunakan gambar analog
untuk membuat sebuah seni, dan juga menawarkan sebuah pengalaman yang mendalam dari sebuah
gambar analog, karena gambar tersebut memiliki tingkat exposure dan kecerahan yang menyerupai
dengan penglihatan dengan mata manusia.
Berikut ini merupakan contoh gambar analog yang diambil menggunakan kamera analog,
yang memenangkan sebuah kontes fotografi pada tahun 2020.

Warna dan kecerahan gambar tersebut mencerminkan warna dan kecerahan yang sama apabila
dilihat dengan menggunakan mata manusia, ditambah dengan cerita dibalik foto tersebut (dapat
dilihat pada referensinya) menambah seni dalam gambar / foto tersebut.

7
Gambar Digital
Konsep
Gambar digital merupakan gambar yang dibentuk dan disimpan dalam sebuah format digital.
Dikatakan sebagai “digital” karena gambar tersebut terdiri dari banyak sekali angka numerik yang
merepresentasikan nilai yang menggambarkan warna dan kecerahan dari sebuah titik pada gambar
tersebut, yang dapat disebut sebagai pixel, dan disimpan sebagai data biner. Kumpulan dari angka -
angka numerik ini akan membentuk gambar digital yang bisa ditampilkan pada perangkat elektronik
seperti monitor komputer atau media cetak. Gambar digital ini dapat terbentuk dari hasil kamera
digital maupun aplikasi elektronik lainnya.
Karena gambar tersebut terbentuk dari sebuah data numerik dimana data numerik tersebut
menggambarkan tingkat warna dan kecerahan dari posisi dimana pixel tersebut berada, maka gambar
tersebut dapat digambarkan sebagai dua dimensi, dimana kita mengenal istilah tersebut sebagai height
dan width, atau secara matematika kita mengenalnya sebagai sumbu x dan sumbu y. Dalam
penggunaan metode image processing pada gambar digital, kita dapat menggunakan teknik
matematika yang menggambarkan kumpulan pixel ini dalam sebuah notasi matematika F(x,y) dimana
x dan y merupakan koordinat posisi dimana pixel tersebut berada.
Berikut ini merupakan salah satu contoh gambar digital yang dibuat menggunakan teknologi
komputer, yang menggabungkan banyak pixel untuk membentuk sebuah gambar dan warna yang pas.

8
Apa itu Pixel?
Kita sebelumnya sudah banyak membahas mengenai pixel. Apa itu pixel? Pixel secara definisi
merupakan komponen terkecil pada sebuah gambar digital yang dapat membentuk sebuah gambar.
Pixel tersebut sebenarnya hanya merupakan angka, dimana apabila banyak pixel digabungkan menjadi
satu, kita bisa melihat sebuah gambar yang terbentuk dari jutaan pixel yang terdiri dari warna yang
berbeda. Hasil resolusi ketajaman dan kecerahan sebuah gambar tergantung dari berapa banyak pixel
yang terdapat pada gambar tersebut. Makin tinggi resolusinya akan menyebabkan pixel semakin
banyak, sehingga hal ini membuat gambar tersebut akan semakin detail dan tajam. Resolusi dari
gambar ini biasanya digambarkan secara horizontal dan vertikal. Kita mungkin sering mendengar
istilah resolusi 1920 x 1080 pixels atau yang biasa dikenal dengan Full HD. Hal ini berarti bahwa
secara horizontal, kita memiliki sebanyak 1920 pixel yang membentuk gambar tersebut dan memiliki
1080 pixel secara vertikal. Pada gambar Full HD, kita dapat memperkirakan bahwa jumlah seluruh
pixel yang ada yaitu 1920 x 1080 = 2.073.600 pixel.

9
Format Gambar Digital
Karena gambar digital merupakan gambar yang kita simpan dalam format digital, tentu
gambar tersebut akan dianggap sebuah file. Kita mengenal ada beberapa format digital yang dapat
digunakan untuk menyimpan file digital tersebut. Kita akan membahas format tersebut satu demi satu
untuk mengetahui kegunaan dari masing - masing format tersebut.

1. JPEG atau JPG (Joint Photographic Experts Group)

Tentu saja format ini merupakan format yang umum kita dengar apabila kita menggunakan
sebuah kamera HP untuk memotret sebuah momen dan menyimpannya dalam HP kita. Format ini
juga umum kita gunakan apabila kita menggunakan sebuah kamera digital untuk mengabadikan
sebuah momen.
JPEG atau JPG ini merupakan format yang umum digunakan, dan kebanyakan dari format ini
dihasilkan dari sebuah kamera digital. Jenis format ini merupakan format yang memiliki performa
buruk apabila kita mengubah ukuran dari gambar ini atau kita melakukan kompresi (menurunkan
ukuran file dengan mengubah ukuran file tersebut). Dengan melakukan kompresi, maka kualitas dari
gambar tersebut juga akan turun. Hal ini menyebabkan format JPEG ini sulit untuk diedit, karena
dapat mengubah kualitas dari gambar itu sendiri. Namun apabila kita memerlukan gambar tersebut
untuk dicetak secara fisik, JPEG ini memiliki resolusi yang terbaik dan merupakan pilihan yang
terbaik, selain itu apabila kita ingin menempatkan sebuah gambar pada website, JPEG ini merupakan
pilihan terbaik, karena kualitasnya yang bagus. Ciri khas dari jenis file ini adalah memiliki nama
‘.jpeg’ atau ‘.jpg’ di akhir nama filenya. Berikut ini merupakan contoh gambar dengan format JPEG.

10
 2. PNG (Portable Network Graphics)
Format ini juga merupakan salah satu format yang umum sering kita temui dan juga gunakan.
PNG banyak digunakan untuk menampilkan visual yang sifatnya dapat interaktif (dapat dilihat dan
dimanipulasi oleh pengguna) seperti pada sebuah web browser. Berbeda dengan JPEG, kualitas PNG
tidak akan berubah walaupun kita merubah ukuran ataupun dimensinya, sehingga kita tetap bisa
memiliki sebuah gambar dengan resolusi rendah, namun dengan kualitas yang tetap tinggi. Oleh
karena itu, PNG sangat cocok untuk kita gunakan apabila kita membutuhkan gambar web dengan
kualitas yang tinggi. PNG juga sering digunakan apabila kita menginginkan sebuah gambar yang
tidak memiliki sebuah latar belakang (background), sehingga pengguna dapat dengan mudah
melakukan manipulasi terhadap objek dalam gambar tersebut tanpa harus memikirkan adanya latar
belakang. Ciri khas dari jenis file ini adalah memiliki format ‘.png’ pada akhir penulisan namanya.
Berikut ini merupakan salah satu contoh bentuk gambar dengan format PNG.

3. Graphics Interchange Format (GIF)

GIF disebut juga dengan gambar animasi. Apabila kita melihat sebuah gambar GIF, kita akan
melihat gambar tersebut dapat bergerak. Dalam bentuk normalnya, GIF terbentuk atas 256 warna
RGB. Karena jumlah warna yang terbatas ini, maka ukuran file tersebut relatif sangat kecil.
Kita telah menyebutkan bahwa GIF ini merupakan gambar animasi yang dapat bergerak.
Gambar ini dapat bergerak karena sesungguhnya gambar ini terbentuk dari banyak layer yang dimana
GIF ini akan menampilkan tiap layer dengan waktu yang relatif cepat. Layer ini akan memiliki pola
gambar yang berurutan, sehingga ketika ditampilkan dengan cepat memiliki terkesan bahwa gambar
tersebut bergerak.

11
 Karena gambar pada GIF ini dapat bergerak, maka kualitas gambar ini diturunkan karena file
tersebut memerlukan memori untuk dapat menampung banyaknya layer dan juga kualitas. Ciri khas
dari file ini adalah memiliki nama ‘.gif’ pada akhir penulisan namanya. Berikut merupakan contoh
dari file GIF berikut.

4. TIFF (Tagged Image File)

TIFF merupakan jenis file gambar yang dimana gambar tersebut dapat pulih kembali ke
ukuran dan versi awal file tersebut apabila kita melakukan perubahan pada file gambar tersebut.
Namun, TIFF membutuhkan waktu agar gambar tersebut kembali pulih, terkadang butuh waktu yang
sangat lama. Karena lamanya proses tersebut, terkadang TIFF digunakan menjadi sebuah format file
ketika kita akan mencetak sebuah foto. Ciri khas file ini adalah memiliki nama ‘.tiff’ pada akhir
namanya. Berikut merupakan contoh dari file TIFF berikut.

5. EPS (Encapsulated Postscript)

EPS merupakan jenis gambar vektor yang dirancang untuk menghasilkan sebuah grafik
gambar dengan resolusi tinggi. EPS kebanyakan dipakai oleh para desainer grafis untuk menyimpan
file gambar vektor tersebut. Uniknya dari bentuk EPS ini adalah, jenis file ini dapat dimodifikasi
dengan aplikasi pengedit gambar apapun yang dapat mendukung pemrosesan gambar vektor.

12
 EPS ini juga dapat diedit dari ukuran pixel maupun ukuran vektor. Dengan demikian, EPS
menjadi sebuah pilihan yang tepat bagi para desainer apabila mereka ingin berkolaborasi satu sama
lain untuk memodifikasi file vektor tersebut. Hal ini juga memungkinkan untuk seseorang
menggunakan file mentah tersebut agar bisa dikembangkan lagi menurut preferensi masing - masing.
Ciri khas dari file ini memiliki tulisan ‘.eps’ pada akhir penulisan namanya. Berikut ini merupakan
contoh file EPS.

Dari pembahasan mengenai gambar analog dan juga gambar digital, kita dapat menyimpulkan
perbedaan dari keduanya pada tabel berikut ini.
Aspek Gambar Analog Gambar Digital

Warna dan kecerahan

Representasi data diskrit
Jenis data memiliki sinyal yang bersifat
yang disebut sebagai pixel
continuous

Jenis penyimpanan Media cetak / fisik Media digital

Mengkonversi gambar
Menggunakan kamera,
analog menjadi digital, atau
Cara pembuatan mesin scan, atau lukisan
membuat digital art
tangan
langsung

Terbatas sesuai dengan

Resolusi gambar Tidak terbatas
jumlah pixel (width x height)

Manual menggunakan
Dengan mudah dapat diedit
Cara pengeditan metode fisik (melukis ulang,
dengan aplikasi desain grafis
mencetak ulang)

Sulit untuk digandakan

Dapat dengan mudah
(perlu adanya proses seperti
Cara penggandaan diduplikasi sebanyak
print, fotokopi, ataupun
mungkin
jiplak)

13
 Aspek Gambar Analog Gambar Digital

Hampir sulit untuk Dapat dengan mudah

Cara Kompresi melakukan kompresi pada dilakukan kompresi untuk
jenis gambar ini mengurangi ukuran file

Rentan terhadap gangguan, Hampir sulit untuk terkena

Noise dan penurunan kualitas gangguan ataupun
gambar penurunan kualitas

Dapat diakses dengan

Perlu adanya kehadiran
melalui perangkat digital
Aksesibilitas manusia untuk dapat
seperti handphone dan
menikmati gambar tersebut
komputer

Dapat dibagikan dengan

mudah dengan cara
Perlu adanya usaha untuk
Distribusi melakukan copy dan paste,
mengirimkan secara fisik
ataupun dikirimkan dengan
melalui internet

Dapat disimpan dengan

Rentan terhadap kerusakan aman tanpa khawatir
Ketahanan Gambar
dan lapuk adanya kerusakan dan
penurunan kualitas

Kita dapat melihat pada tabel diatas perbedaan dari masing - masing gambar analog dan juga
gambar digital. Kita dapat melihat bahwa antara gambar analog dan juga digital, banyak sekali
perbedaannya, dan memiliki sifat yang berbeda - beda tergantung dari jenis gambar itu sendiri. Bagi
orang yang menyukai sebuah seni, mungkin mereka akan lebih senang jika melihat gambar analog,
namun mungkin bagi orang yang ingin memiliki gambar dengan simpel, dapat menggunakan gambar
digital karena sifatnya yang praktis untuk dibuat dan disimpan.
Setelah kita memahami gambar analog dan juga berbagai macam bentuk gambar digital, kita
akan memahami bagaimana cara kita menginterpretasikan gambar tersebut. Kita sebagai manusia
dapat dengan mudah menyerap informasi dari sebuah gambar hanya dengan melihatnya, karena kita
memiliki mata sebagai bagian tubuh yang menyerap informasi visual, dan juga otak yang digunakan
untuk memproses informasi tersebut.

14
 Pada kesempatan ini, kita akan membahas bagaimana cara sebuah komputer dapat
mengekstrak sebuah informasi dari sebuah gambar visual, layaknya seperti apa yang dilakukan oleh
manusia. Apakah cara yang digunakan sama seperti cara yang digunakan manusia? Ilmu yang
mempelajari hal ini kita sebut sebagai Computer Vision.

Computer Vision
Sebelumnya, kita telah membahas dua macam gambar yang dapat dihasilkan, yaitu
gambar analog dan juga gambar digital. Manusia dapat dengan mudah melihat gambar tersebut, dan
menarik informasi dari gambar tersebut. Apabila kita sebagai manusia melihat gambar berikut ini :

Manusia akan dengan mudah mengidentifikasi gambar tersebut merupakan gambar

sebuah kucing persia putih. Namun, bagaimana cara sebuah komputer membaca gambar tersebut?
Pada kenyataannya, komputer tidak dapat dengan mudah membaca gambar tersebut dan
mengidentifikasi informasi didalamnya bahwa gambar tersebut merupakan gambar kucing. Ketika
manusia dan komputer menerima sebuah gambar, berikut ini merupakan hal yang mereka lihat :

15
 Komputer membaca gambar dalam bentuk angka yang kita sebut juga dengan pixel.
Hal ini disebabkan karena mereka membaca nilai pixel pada lokasi tersebut, dan mengubahnya
menjadi data numerik yang merepresentasikan sebuah warna dan kecerahan pada titik tersebut. Data
ini yang dibaca oleh komputer, yang akhirnya akan diterjemahkan menjadi kumpulan warna yang
dapat kita visualisasikan sebagai manusia. Karena komputer hanya bisa membaca dan memproses
sebuah gambar pada level pixel yang merupakan sebuah data numerik, kita dapat melakukan
beberapa operasi dan proses berdasarkan nilai numerik pada tiap pixel tersebut. Untuk menganalisa
gambar tersebut dan menyerap informasi lebih dalam pada sebuah gambar, seperti menganalisa
objek ataupun mencari pemahaman pada kontennya, kita dapat mengaplikasikan beberapa teknik
dan algoritma yang digunakan untuk memproses data numerik tersebut pada level yang lebih tinggi.
Algoritma tersebut melibatkan proses matematika kompleks dan juga model statistik
yang dapat digunakan untuk mengekstrak fitur, pola, dan struktur dari data pixel. Dengan
menganalisa pola dan relasi antar pixel, komputer dapat menganalisa sebuah objek,
mengklasifikasikan gambar, mendeteksi garis tepi, dan juga analisa lainnya pada gambar. Analisa
dengan menggunakan algoritma tersebut yang sering kita jadikan sebuah cabang ilmu sendiri, yaitu
Computer Vision.
Computer Vision sendiri merupakan cabang dari pembelajaran pada Artificial
Intelligence yang bisa membuat komputer mendapatkan informasi dari gambar, video, ataupun dari
input lain yang berhubungan dengan informasi visual. Dengan adanya metode computer vision ini,
terkadang kita bisa mendapatkan informasi yang penting yang mungkin sulit untuk dideteksi oleh
mata manusia, dengan menggunakan bantuan beberapa teknik yang dapat diterapkan pada computer
vision. Beberapa aplikasi computer vision yang umum digunakan antara lain adalah : (1) Pendeteksi
object : Digunakan agar komputer dapat mengetahui nama atau suatu objek berdasarkan bentuk
visual dari objek itu, (2) Pendeteksi wajah : Digunakan agar komputer dapat mengenali manusia,
(3) Pendeteksi penyakit : Digunakan pada dunia medis untuk mendeteksi adanya anomali pada
organ manusia, (4) Mobil otomatis : Digunakan pada mobil agar dapat menghindari benda secara
otomatis.

16
 Computer Vision ini memiliki beberapa topik yang dapat dibahas seperti image
preprocessing, feature extraction, pattern recognition, dan juga beberapa aplikasi Machine
Learning. Salah satu proses yang akan kita lakukan saat mempelajari Computer Vision ini adalah
Image Processing. Kita akan membahas mengenai topik ini sebelum kita belajar lebih jauh
bagaimana cara kita mengolah gambar.

Image Processing
Image Processing adalah sebuah studi dan metode untuk mengubah sebuah gambar menjadi
sebuah format digital dan melakukan beberapa operasi pada gambar tersebut. Operasi yang
dilakukan bertujuan untuk mencari informasi dari gambar visual tersebut agar kita mendapatkan
informasi yang lebih dalam yang mungkin luput dari penglihatan dengan mata. Beberapa operasi
yang umum dilakukan pada gambar meliputi penguatan gambar (image enhancement), pengaburan
gambar (image blurring), pengubahan warna (image recoloring), dan operasi - operasi lainnya yang
dapat membantu kita untuk mengekstrak informasi. Beberapa aplikasi umum yang dapat digunakan
dengan menggunakan image processing antara lain adalah sebagai berikut :

Forensik
Dengan mudahnya manipulasi gambar digital, kita bisa membuat sebuah informasi yang
mungkin luput apabila dilihat dengan mata, menjadi terlihat dengan beberapa operasi tertentu.

17
 Dalam dunia forensik dan investigasi kriminal, penggunaan image processing dapat
membantu manusia untuk melihat sebuah gambar lebih jelas sehingga mudah untuk
mengidentifikasi sebuah bukti. Pada zaman sekarang dengan canggihnya teknologi, makin banyak
investigator yang menggunakan sebuah proses digital untuk memperkuat warna pada gambar, atau
menggunakan deteksi sudut, ataupun teknik operasi yang lainnya.

Medis
Jaman sekarang banyak dunia medis yang menggunakan sebuah image processing untuk
membentuk sebuah gambar digital dari tubuh manusia. Gambar ini dapat digunakan untuk
mendeteksi apakah ada virus atau penyakit tertentu dalam tubuh manusia. Beberapa aplikasi umum
pada dunia medis yaitu CT Scan, X-Ray, dan juga deteksi tumor.

Deteksi Gerakan & Transportasi

Teknologi ini digunakan untuk mengumpulkan informasi mengenai rutinitas yang sering kita
lakukan. Terkadang dapat dikumpulkan menggunakan kamera untuk mendeteksi objek yang
bergerak untuk melakukan klasifikasi ataupun analisa lanjutan. Salah satu aplikasi yang telah
diterapkan yaitu penggunaan GPS tracking seperti Google Maps untuk mendeteksi lokasi kita dan
juga mendeteksi apakah ada kemacetan pada jalanan ataupun rute yang akan kita tempuh.

Kamera Digital
Mungkin kita pernah melihat kamera digital yang dilengkapi dengan peralatan dan aplikasi
yang memungkinkan untuk memproses gambar tersebut secara langsung, biasanya banyak
digunakan apabila kita menggunakan jasa photobooth. Secara cepat, kita dapat mengambil momen
sekaligus menggunakan operasi image processing untuk mengolah gambar tersebut agar terlihat
lebih bagus dan jelas, lalu gambar tersebut dapat dicetak ditempat ataupun dikirimkan melalui
internet.

18
 Setelah membahas mengenai beberapa aplikasi image processing dalam kehidupan
manusia, kita akan mempelajari metode yang digunakan untuk melakukan hal tersebut dan
bagaimana cara kita membuat programnya. Secara konsep dan alat, kita sebenarnya telah mengenal
sebagian besar metode yang digunakan, namun perbedaan mendasar adalah kali ini kita memiliki
input berupa gambar visual.
Sebagian besar metode yang digunakan dalam Computer Vision ini bergantung pada
beberapa metode Machine Learning dan juga Deep Learning, dimana metode tersebut meliputi
pelatihan data menggunakan neural networks dan melatih dataset yang besar untuk mempelajari
pola yang ada pada gambar tersebut. Salah satu metode Deep Learning yang digunakan untuk
mengatasi masalah ini adalah Convolutional Neural Network (CNN), yang paling umum
digunakan dalam beberapa metode pada computer vision ini.
Walaupun kita belum membahas mengenai CNN pada materi Deep Learning, kita akan
mencoba untuk membahas materi tersebut pada bab ini. Sebelum kita membahas lebih jauh
mengenai bagaimana caranya kita menerapkan metode Deep Learning ataupun metode lainnya
untuk memproses gambar, kita akan membahas sebuah library pada Python yang dapat kita gunakan
untuk melakukan pemrosesan pada gambar visual, yaitu OpenCV.

Istilah pada Computer Vision

Sebelum kita masuk lebih dalam untuk membuat algoritma untuk mengolah data gambar,
kita akan mencoba untuk membahas beberapa istilah yang umum digunakan, sehingga nantinya
ketika kita akan membuat algoritmanya maka kita sudah memahami konsep dan istilah yang
digunakan.

1. Channel

Pada pengolahan data gambar, umumnya kita akan banyak menggunakan istilah channel.
Dalam Computer Vision, kita biasanya mengartikan channel sebagai sebuah warna individu atau
bisa dikatakan sebuah lapisan informasi warna yang membentuk sebuah gambar. Sebuah warna pada
gambar umumnya memiliki beberapa lapisan channel tertentu.

19
 Untuk sebuah gambar dengan warna grayscale (hanya hitam, putih atau abu - abu) akan
memiliki hanya 1 channel warna saja untuk menentukan intensitas cahayanya. Biasanya jenis
gambar dengan warna grayscale ini digunakan ketika informasi mengenai warna tidak terlalu
dibutuhkan, seperti edge detection ataupun corner detection.
Untuk sebuah gambar berwarna, umumnya kita memiliki tiga channel warna. Channel ini
ada untuk masing - masing warna merah, hijau, dan biru. Masing - masing nilai pada tiap channel
ini akan merepresentasikan tingkat intensitas warna tiap channel pada gambar. Ketika ketiga
channel ini memiliki intensitas warna seluruhnya adalah 0, maka warna hitam akan dihasilkan,
sedangkan apabila seluruhnya adalah 255 (untuk channel warna 8 bit) akan menghasilkan warna
putih. Nilai di antara 0 dan 255 akan menghasilkan warna tergantung dari tingkat intensitas pixel
masing - masing channel, dengan channel yang nilai pixel paling tinggi akan menjadi warna yang
paling dominan.

2. Kernel

Dalam image processing, kernel merupakan sebuah filter yang digunakan untuk berbagai
operasi terhadap gambar. Dalam bentuk matematikanya, sebuah kernel merupakan matriks, yang
ukurannya biasanya disimbolkan dalam notasi K (angka ganjil). Kernel ini diaplikasikan dengan
cara melakukan konvolusi, dimana proses ini merupakan perkalian antar matriks (sebuah gambar
berbentuk matriks ketika dibaca oleh komputer).

Permasalahan Utama Computer Vision

Dalam computer vision, sebuah aplikasi umum yang sering dibahas adalah bagaimana cara
kita melakukan klasifikasi dari sebuah gambar. Sebagai contoh, misalkan kita mempunyai sebuah
gambar dengan ukuran tertentu, seperti tinggi dan lebar sebuah objek pada gambar. Dengan ukuran
yang berbeda, ada potensi bahwa model computer vision yang dibuat dapat mendeteksi klasifikasi
lainnya. Perhatikan ilustrasi berikut ini.

20
 Sebagai ilustrasi, kita akan melihat gambar disamping.
Misalkan kita memberikan label “kucing” pada gambar
disamping berikut ini. Karena gambar kucing tersebut
merupakan gambar berwarna, maka kita akan memiliki 3
channel warna (merah, biru, dan hijau). Dengan ukuran gambar
dimana lebar 248 pixel dan tinggi 400 pixel, maka jumlah angka
yang akan diproses oleh model adalah sebanyak 248 x 400 x 3 =
297.600 pixel. Angka ini yang nantinya akan digunakan untuk
melakukan prediksi oleh model, agar bisa mengetahui gambar
apakah gambar tersebut.

Kucing

Sebuah komputer hanya dapat melihat gambar sebagai angka. Dengan total sejumlah
297.600 pixel yang kita miliki dari sebuah gambar kucing, maka kita harus membuat agar model
dapat menentukan klasifikasi berdasarkan total 297.600 pixel tersebut. Ketika kita memiliki
gambar kucing lainnya, kita akan memberikannya pada model untuk dilakukan klasifikasi, dan
berdasarkan hasil yang diperoleh, 82% hasil prediksi menunjukkan bahwa gambar tersebut adalah
gambar kucing.

21
 Masalah seperti apakah yang dapat timbul dari gambar tersebut? Kita akan mencoba untuk
membahas beberapa permasalahan umum yang terjadi ketika kita melakukan pemrosesan gambar
dengan menggunakan image processing.

1. Variasi Sudut Pandang

Salah satu permasalahan umum yang dapat terjadi apabila adanya perbedaan sudut pandang
dari sebuah gambar. Perhatikan contoh gambar berikut ini.

Kita dapat melihat bahwa pada contoh gambar diatas, ketiganya merupakan gambar yang
serupa. Namun gambar tersebut terlihat berbeda karena adanya perbedaan sudut pandang
pengambilan gambar. Karena komputer membaca sebuah gambar dalam bentuk pixel, maka ketiga
tersebut dapat dianggap sebagai 3 gambar yang berbeda satu sama lain oleh komputer.

2. Variasi Perbedaan Ukuran

Sama seperti masalah yang pertama, perbedaan ukuran dari sebuah objek pada gambar dapat
dianggap fitur yang berbeda oleh model. Perhatikan contoh gambar berikut ini.

22
 Kedua objek dalam gambar tersebut merupakan manusia. Karena objek manusianya
memiliki ukuran berbeda dalam sebuah gambar yang sama, maka ada kemungkinan bahwa model
kita akan salah mengklasifikasikan gambar tersebut, karena adanya perbedaan ukuran.

3. Deformasi

Deformasi merupakan istilah dimana adanya perbedaan bentuk dari gambar yang
sebenarnya. Bentuk ini umum terjadi ketika objek tidak memiliki bentuk yang seharusnya sesuai
dengan bentuk yang sudah didefinisikan ketika kita melatih model kita untuk melakukan sebuah
klasifikasi gambar tertentu. Sebagai contoh, mari kita lihat gambar berikut ini.

Pada gambar kucing diatas, kita melihat bentuk yang berbeda dari kucing pada umumnya.
Kucing pada gambar tersebut terlihat sedang tertidur dan membentuk posisi yang tidak seperti
kebanyakan gambar kucing lainnya. Hal ini dapat menyebabkan model salah untuk melakukan
klasifikasi terhadap gambar tersebut.

4. Occlusion

Occlusion merupakan sebuah istilah dimana suatu objek pada gambar terhalang/ditutupi
objek lainnya. Hanya sebagian saja objek yang terlihat dalam gambar. Hal ini dapat menyebabkan
informasi yang digunakan oleh model tidak lengkap, sehingga dapat menghasilkan hasil prediksi
yang mungkin kurang baik. Berikut ini merupakan sebuah contoh gambar kucing yang terhalang
dengan objek lain, sehingga hanya terlihat sebagian saja.

23
 5. Background Clutter

Background Clutter merupakan sebuah istilah yang digunakan ketika sebuah objek yang
sedang diobservasi berbaur dengan lingkungannya. Kita mengetahui bahwa model akan menilai
berdasarkan pixel yang ada pada gambar. Apabila gambar objek berbaur dengan lingkungannya, ini
akan menyulitkan model untuk mendeteksi objek yang ada pada gambar tersebut. Berikut ini
contoh dari gambar yang memiliki permasalahan background clutter tersebut :

6. Illumination Conditions

Illumination Conditions merupakan sebuah kondisi dimana terjadinya perbedaan kecerahan

pada gambar secara drastis pada level pixel. Untuk sebuah objek yang sama, ketika kita memiliki
pencahayaan yang sangat berbeda, maka ada kemungkinan model dapat melakukan prediksi yang
salah terhadap gambar. Berikut ini merupakan contoh gambar yang memiliki permasalahan
illumination conditions ini :

24
 7. Intra-Class Variation

Intra-Class Variation merupakan sebuah variasi gambar dari gambar yang memiliki
klasifikasi yang sama. Sebagai contoh, apabila kita melakukan klasifikasi terhadap kategori
“Kursi”. Apabila bentuk dari kursi ini berbeda - beda, maka model cenderung akan kesulitan untuk
melakukan klasifikasi tersebut. Perhatikan contoh gambar yang memiliki permasalahan intra-class
variation berikut ini :

OpenCV
OpenCV (Open Source Computer Vision) merupakan sebuah
library yang bersifat secara publik dan digunakan untuk melakukan
proses yang melibatkan pengolahan gambar ataupun media visual.
Kita tidak menyebutkan OpenCV ini merupakan library Python,
karena OpenCV ini memang awalnya dirancang untuk dapat
digunakan di beberapa bahasa pemrograman, seperti C++, Java, dan
juga Python.

25
Scikit Image
Scikit Image (skimage) merupakan salah satu library
pada Python yang bersifat open source, digunakan untuk
melakukan beberapa fungsi yang berkaitan dengan penggunaan
machine learning untuk permasalahan image processing dan
juga mencari pola tersembunyi dari data image tersebut.

Skimage ini dibangun atas beberapa kumpulan library Python lainnya, seperti NumPy,
SciPy, dan Matplotlib. Skimage ini dibuat dan dikhususkan untuk pemula maupun yang sudah
mahir untuk dapat menggunakan library Computer Vision untuk dapat mengolah gambar.
Beberapa fungsi penting yang sering digunakan pada library ini adalah :
1. Image I/O : Dengan menggunakan fungsi ini, kita bisa membaca gambar dalam format -
format digital yang ada, baik dari sebuah file yang kita punya maupun sebuah link URL dari
gambar tersebut.
2. Image Transformation : Kita bisa mengaplikasikan beberapa transformasi geometri seperti
rotation, scaling, cropping, dan flipping.
3. Image Filter : Filter digunakan untuk mengekstrak fitur, noise reduction dan image
enhancement. Kita bisa mengaplikasikan beberapa teknik filter seperti blurring, deteksi
sudut, noise removal, dan sharpening.
4. Manipulasi Warna : Kita bisa menggunakan fungsi dalam skimage ini untuk mengubah
warna dari gambar seperti RGB, BGR, HSV, dan lainnya. Kita bisa juga mengubah kontras
dan intensitas cahayanya.
5. Feature Extraction : Skimage memiliki beberapa algoritma untuk feature extraction, seperti
deteksi sudut, pinggiran, blobs, dan penerjemah tekstur. Beberapa fitur ini banyak
digunakan untuk keperluan deteksi objek dan pengenalan objek.
Masih banyak lagi kegunaan dari skimage ini. Kita akan menggunakan skimage ini
bersamaan dengan OpenCV, agar kita dapat melakukan analisa visual terhadap gambar.

26
Fungsi Dasar OpenCV
OpenCV ini sendiri memiliki beberapa algoritma dan juga fungsi yang dapat diaplikasikan
oleh programmer untuk dapat membangun sebuah aplikasi yang melibatkan Computer Vision.
Berikut ini kita akan membahas beberapa aplikasi dan fungsi dasar yang bisa kita gunakan dengan
OpenCV ini.

1. Membaca dan Menulis kembali Gambar

Fungsi membaca sebuah gambar dan menulis kembali sebuah gambar mungkin dapat
dikatakan merupakan salah satu fungsi yang umum dan wajib kita ketahui sebelumnya. Kita akan
melakukan pemrosesan gambar menggunakan library OpenCV pada Python, sudah seharusnya kita
mengetahui bagaimana cara kita memanggil gambar tersebut agar bisa diolah ke dalam Python itu
sendiri. Untuk menggunakan OpenCV pada Python, kita bisa menginstal dulu library yang akan
digunakan, yaitu opencv-python. Perhatikan penulisannya pada Google Colab berikut ini.

Setelah menginstal library OpenCV, kita akan mencoba untuk membaca file gambar. Kita
akan mencoba untuk membaca file gambar yang ada pada Google Drive kita. Berikut ini contoh
penulisan sintaksnya.

Ketika kita menjalankan sintaks tersebut, kita akan memunculkan gambar yang berada pada
lokasi pada Google Drive tersebut. Perhatikan untuk menampilkan gambar tersebut pada Google
Colab, kita dapat menggunakan sebuah fungsi bawaan dari Google Colab yaitu cv2_imshow, yang
memiliki fungsi seperti plt.show() pada matplotlib. Ketika kita menjalankan sintaks tersebut,
gambar yang keluar adalah seperti berikut ini :

27
 Gambar tersebut akan dipanggil sesuai dengan ukuran gambar aslinya, karena kita tidak
melakukan transformasi untuk mengubah gambar tersebut. Apabila gambar tersebut ingin kita ambil
dari sebuah link website ataupun dari browser, kita juga bisa melakukan hal tersebut dengan
menuliskan link dari gambar tersebut. Perhatikan contoh berikut ini. Kita akan mengambil gambar
siberian husky tersebut dari sumber aslinya, yaitu pada link ini.

28
 Perhatikan disini kita untuk mengambil gambar dari sebuah link, kita menggunakan library
skimage, yaitu library scikit-learn seperti yang telah kita bahas pada materi Machine Learning,
namun digunakan khusus untuk memproses data visual. Perhatikan bahwa gambar yang kita ambil
dari link tersebut memiliki warna yang berbeda. Apabila kita membuka link tersebut dari sumber
aslinya, maka seharusnya warna gambar tersebut adalah seperti ini :

Hal ini dapat terjadi karena library OpenCV tersebut membaca dan menampilkan gambar
dalam format BGR (Blue, Green, Red). Pada umumnya, pixel pada gambar ditampilkan dalam
format RGB (Red, Green, Blue), dan pada OpenCV ini, format pixelnya dibaca dalam BGR,
sehingga komponen pixel Blue dan Red akan tertukar, sehingga kita mendapatkan gambar dengan
warna yang berbeda. Oleh karena itu, kita akan mengubah pixel tersebut dengan menggunakan
fungsi cv2.cvtColor untuk menuliskan perubahan pixel tersebut, lalu memberikan fungsi
cv2.COLOR_BGR2RGB untuk mengubah warna dari BGR ke RGB. Perhatikan contoh penulisan
sintaksnya berikut ini.

29
 Gambar yang dibaca akan sama dengan gambar yang ada di link, dan juga yang ada pada
Google Drive kita. Oleh karena itu, kita harus perhatikan apabila kita akan mengambil gambar
dengan menggunakan OpenCV terutama yang sumbernya berasal dari sebuah link, kita terkadang
perlu melakukan konversi pixel dengan menggunakan cv2.cvtColor untuk mengubah warna dari
gambar tersebut.
Setelah mencoba untuk membaca file, kita akan coba untuk membuat kembali gambar
tersebut.

Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan bahwa sebuah file akan
terbentuk pada Google Colab kita, bernama ‘siberian_husky_new.jpg’. Perhatikan screenshot
berikut ini.

30
 Apabila gambar tersebut kita buka dan cek, kita akan mendapati bahwa gambar tersebut
sama seperti gambar siberian husky yang kita ambil dari link sebelumnya.

2. Mengubah Warna pada Gambar

Seperti yang telah dijelaskan pada pembahasan mengenai skimage, kita dapat mengubah
warna dari sebuah gambar dengan menggunakan beberapa fungsi yang ada di library tersebut.
Perubahan warna yang kita maksudkan disini adalah perubahan color space, dan bukan warna dari
bagian pada gambar. Beberapa color space yang ada adalah HSL, HSV, RGB, BGR, dan
Grayscale. Color space ini dapat dikatakan merupakan sebuah kategori kumpulan warna yang
digunakan untuk membangun gambar tersebut. Kita biasa mengubah warna pada gambar tersebut
karena ada beberapa proses yang memerlukan kita untuk menggunakan color space tertentu. Selain
itu, dengan merubah warna, kita bisa mendapatkan kontras yang lebih tinggi, warna gambar yang
lebih stabil, dan juga warna yang lebih umum untuk digunakan pada beberapa proses tertentu pada
image processing.
Kita hanya akan membahas konsep warna untuk HSL, HSV, dan RGB saja pada kesempatan
kali ini. Sejauh ini, kita mengenal bahwa RGB merupakan singkatan dari Red, Green, Blue yang
dikenal sebagai warna dasar yang apabila dicampur dapat menciptakan sebuah kombinasi warna
lainnya yang merepresentasikan warna pada gambar.

31
 Pada tahun 1970, HSL (Hue, Saturation, Lightness) dan HSV (Hue, Saturation, Value)
diciptakan sebagai sebuah alternatif warna terhadap RGB. HSL dan HSV ini merupakan jenis color
space yang warnanya mendekati warna sebenarnya apabila dilihat dengan mata manusia.
Pada RGB, kita menentukan sebuah warna berdasarkan komposisi dari masing - masing
komponen R, G, dan B nya. Apabila kita gambarkan secara visual, kita bisa mendapati bahwa RGB
berbentuk seperti kubus berikut ini.

Sedangkan pada HSL dan HSV, kita memiliki representasi visual seperti sebuah silinder.
Pada HSL, kita melihat bahwa nilai L menentukan apakah warna tersebut mendekati terang atau
gelap, sedangkan pada HSV, V menentukan warnanya sendiri. H menentukan warna sama seperti
RGB dan S menentukan saturasi dari warna tersebut.

Pada bagian sebelumnya, kita sebenarnya telah menerapkan salah satu fungsi dari OpenCV
yang digunakan untuk mengubah warna, yaitu cv2.cvtColor() karena ketika kita membaca file dari
URL, secara default akan dianggap sebagai gambar BGR, sehingga kita perlu mengubahnya
kedalam bentuk RGB.

32
 Untuk mengubah warna color space pada gambar, kita bisa menggunakan fungsi
cv2.cvtColor() seperti pada sebelumnya. Perhatikan contoh berikut ini.

Dengan jenis color space yang berbeda - beda tersebut, kita dapat menghasilkan subplot
gambar seperti berikut ini :

33
 3. Mengubah ukuran gambar
Untuk mengubah ukuran dari gambar, kita dengan mudah mengubah jumlah pixel yang ada
pada gambar tersebut. Dari bagian teori mengenai gambar digital, kita mengetahui bahwa gambar
dibangun atas sejumlah pixel. Dengan mengurangi jumlah pixel tersebut, kita dapat secara otomatis
mengubah ukurannya. Perhatikan contoh cara pemrogramannya berikut ini.

Kita akan mengeluarkan keduanya bersamaan untuk membandingkan ukurannya.

34
 4. Mengubah lokasi gambar (Translation)
Translation merupakan istilah pada Computer Vision untuk memindahkan lokasi gambar.
Lokasi yang dimaksudkan adalah dengan mengubah titik tengah dari gambar. Ketika kita
menampilkan sebuah gambar, kita membayangkan seperti menonton sebuah televisi yang berisikan
keseluruhan gambar yang dimuat dalam layar. Apabila kita menggunakan translation, posisi
gambar tersebut akan berpindah, sehingga mengakibatkan kita mungkin melihat bagian kosong pada
layar televisi. Berikut merupakan ilustrasi dari konsep translation.

Kita akan mencoba untuk membuat sebuah program untuk memindahkan posisi gambar
tersebut. Fungsi yang kita gunakan untuk memindahkan adalah warpAffine(). Berikut merupakan
contoh programnya.

35
 Dengan menjalankan program tersebut, kita akan mendapatkan perbandingan antara hasil
sebelum translation dan sesudah translation.

5. Memutar gambar (Rotation)

Untuk memutar gambar, kita perlu melakukan dua hal. Agar OpenCV dapat mengetahui
bagaimana cara kita memutar sebuah gambar, kita perlu memberikan lokasi titik tengah, sudut
perputaran, juga ukuran hasil perputaran tersebut. Kita menggunakan fungsi
cv2.getRotationMatrix2D(titik_tengah, sudut, ukuran) untuk mendefinisikan bagaimana cara kita
akan memutar dan mengubah sudut dari gambar tersebut.

36
 Fungsi ini akan menghasilkan sebuah matriks baru yang dinamakan matriks rotasi, yang
memiliki rumus seperti berikut :

Untuk matriks dua dimensi, kita akan memiliki rumus matriks rotasi seperti gambar diatas.
Untuk matriks tiga dimensi, kita akan memiliki rumus berikut :

Kita tidak perlu khawatir bagaimana cara membuat matriks tersebut. Dengan menggunakan
fungsi cv2.getRotationMatrix2D, kita akan mendapat matriks tersebut. Perhatikan contoh program
berikut.

37
 Dengan menjalankan program tersebut, kita akan mendapatkan hasil seperti berikut ini :

Dengan menuliskan scaling factor adalah 1, maka ukuran gambar tersebut tidak berubah
(perhatikan bahwa ukuran tersebut terlihat berbeda karena penyesuaian pada modul ini
ketika dilakukan proses copy dan paste dari Google Colab). Untuk melihat nilai matriks rotasi
yang dihasilkan, kita dapat mengeluarkan nilai matriks tersebut.

38
 6. Image Thresholding
Image Thresholding merupakan sebuah proses yang kita gunakan untuk mengkonversi
sebuah nilai pixel menjadi nilai lain yang sudah ditentukan. Ketika pada gambar kita memiliki
sebuah nilai pixel yang nilainya lebih tinggi dari nilai pixel yang kita tentukan sebelumnya, maka
secara otomatis nilai tersebut akan diubah menjadi nilai yang telah ditentukan, begitu juga dengan
nilai pixel yang nilainya lebih rendah, mungkin dapat kita turunkan agar menjadi suatu nilai pixel
yang kita tentukan sebelumnya (yang bernilai lebih rendah). Dengan demikian, sebuah gambar yang
kaya akan warna hanya akan memiliki beberapa jenis warna saja karena kita menerapkan
thresholding. Salah satu contoh aplikasi ini adalah membuat sebuah gambar menjadi berwarna
hitam dan putih (black and white).
Pada OpenCV, kita memiliki beberapa fungsi thresholding yang umum digunakan, berikut
merupakan fungsi tersebut dan penjelasannya.

Pada kelima fungsi threshold diatas, kita akan membutuhkan dua buah nilai input, yaitu nilai
thresh dan juga nilai maxval yang akan digunakan. Thresh merupakan nilai batas yang digunakan
untuk menentukan batas perubahan nilai pixel, sedangkan maxval merupakan nilai maksimum pixel
tersebut. Biasanya, sebagai contoh kita menggunakan nilai thresh adalah 127 (nilai tengah dari
pixel) dan nilai maxval adalah 255 (nilai maksimum dari pixel). Kita juga menyertakan fungsi
threshold diatas untuk memilih seperti apa cara kita menerapkan thresholding pada gambar.

39
Berikut ini merupakan contoh penerapan fungsi thresholding dasar pada Python.

40
 Pada penulisan fungsi cv2.threshold() diatas, kita menuliskan parameter berupa
cv2.threshold(gambar, thresh, maxval, fungsi_threshold). Kita bisa mengubah nilai threshold
dengan mencoba untuk mengubah nilai thresh, untuk dapat melihat hasil yang berbeda.
Selain menggunakan fungsi threshold dimana kita menyatakan nilai threshold langsung, kita
bisa juga menggunakan Adaptive Threshold, dimana nilai threshold ini akan menyesuaikan dengan
nilai pixel pada gambar. Adaptive Threshold bekerja dengan membandingkan nilai pixel tersebut
dengan nilai pixel tetangganya. Jumlah pixel tetangganya yang diambil bisa sejumlah nilai yang
sudah pasti, ataupun bisa juga merupakan nilai variabel. Ada dua cara untuk menggunakan
Adaptive Threshold ini, yaitu dengan Mean Adaptive Thresholding, dimana kita menggunakan
nilai rata - rata dari seluruh pixel tetangga untuk menentukan nilai threshold pixel tersebut, atau
dengan metode Gaussian Adaptive Thresholding, dimana tiap pixel diberikan sebuah pembobotan
untuk menentukan nilai pixel yang jadi patokan dengan menggunakan distribusi Gaussian. Berikut
ini merupakan contoh penggunaan dari Adaptive Threshold dengan cv2.THRESH_BINARY.

41
 Pada fungsi cv2.adaptiveThreshold() diatas, kita bisa memasukan parameter sebagai
berikut : cv2.adaptiveThreshold(gambar, maxval, fungsi_adaptive, fungsi_threshold,
jumlah_pixel_tetangga, nilai_konstanta_untuk_selisih_mean). Maxval merupakan nilai
maksimum pixel. Fungsi adaptive merupakan fungsi Adaptive Threshold yang kita bahas
sebelumnya, dan fungsi threshold disini merupakan fungsi threshold yang kita coba sebelumnya.
Jumlah pixel tetangga merupakan jumlah pixel disekitar pixel acuan yang akan dijadikan patokan
dan biasanya dipilih angka ganjil seperti 3, 5, 7, dan lainnya, sedangkan nilai_konstanta
merupakan sebuah nilai bobot yang akan digunakan untuk mengurangi nilai rerata, dapat berupa
nilai positif maupun negatif.
Dengan menggunakan adaptive threshold, kita bisa melihat sebuah gambar dengan nilai
batas hitam dan putih yang lebih halus dibandingkan tidak menggunakan adaptive threshold. Kita
dapat memainkan nilai konstanta dan juga jumlah pixel tetangga untuk mendapatkan gambar sesuai
dengan yang kita inginkan.

42
 7. Image Blurring dan Image Smoothing
Image Blurring dan Image Smoothing merupakan sebuah teknik umum yang digunakan
untuk menyingkirkan warna yang mengganggu (noise), atau membantu aplikasi kita untuk dapat
berfokus kepada bagian tertentu saja (fitur). Terkadang, metode blurring dan smoothing ini digabung
dengan metode deteksi sudut (edge detection). Pada prinsipnya, pada Image Blurring, kita akan
menggabungkan gambar dengan sebuah filter kernel low-pass sedangkan pada Image Smoothing,
kita akan membuat gambar menjadi berbayang (blur) dengan beberapa low-pass filter yang
diaplikasikan kepada bagian - bagian tertentu pada gambar.
Kernel merupakan sebuah matriks yang digunakan untuk melakukan berbagai macam
proses image processing, seperti smoothing, blurring, dan lainnya. Kernel biasanya berupa matriks
berukuran ganjil, apabila kita memiliki kernel dengan K = 5, maka kita akan membentuk sebuah
kernel dengan ukuran 5 x 5. Pada teknik image processing, kita menyatakan jumlah kernel yang
akan kita gunakan, misalkan 3. Kita akan melihat 3x3 atau 9 kotak yang ada di sekitar pixel acuan,
lalu mengkalikan nilai tersebut dengan nilai - nilai tertentu sesuai nilai pada matriks tersebut, lalu
hasil perkalian tersebut menjadi nilai baru untuk pixel acuan yang kita pilih tersebut. Gambar
berikut ini merupakan contoh kernel yang digunakan untuk mengaburkan (blur) gambar.

Untuk dapat mencoba dan melihat efek dari kernel pada gambar, kita dapat mengakses
website : https://setosa.io/ev/image-kernels/ dimana kita memiliki beberapa contoh matriks kernel
yang digunakan untuk mengaplikasikan beberapa teknik image processing.

43
 Kita akan mencoba untuk menerapkan aplikasi dari smoothing dan blurring ini. Untuk dapat
melihat lebih jelas aplikasi dari smoothing dan blurring ini, kita akan menggunakan gambar
siberian husky yang sama seperti yang kita gunakan sebelumnya, namun kita akan menambahkan
sebuah teks lalu menerapkan smoothing dan blurring ini untuk menonjolkan teks tersebut pada
gambar. Perhatikan sintaks Pythonnya berikut ini.

Dengan menggunakan cv2.putText(), kita bisa memasukan parameter yang dibutuhkan

untuk menambahkan teks berisi ‘siberian husky’ pada gambar. Ketika kita menjalankan sintaks
diatas, kita akan mendapatkan array seperti berikut.

44
 Ketika kita menjalankan sintaks tersebut, kita mendapatkan nilai array pada gambar. Yang
dilakukan disini adalah OpenCV menambahkan tulisan tersebut pada lokasi yang kita tentukan,
sehingga mengubah sebagian warna pada gambar agar menampilkan tulisan ‘siberian husky’.
Untuk melihat bentuk gambar tersebut, kita dapat menggunakan cv2_imshow() untuk menampilkan
gambarnya.

Setelah ini, kita akan membuat sebuah kernel yang akan berperan untuk membuat gambar
menjadi smooth atau blur. Kali ini kita akan mencoba menggunakan kernel rata - rata dengan
ukuran K = 5. Perhatikan sintaksnya berikut ini.

Dengan menggunakan kernel diatas, seluruh nilai pada pixel acuan akan dikalikan dengan
nilai kernel tersebut.

45
 Kita akan menggunakan fungsi cv2.filter2D(), dimana fungsi ini akan melakukan konvolusi
kernel terhadap gambar kita. Dengan menggunakan kernel berisi angka 1 rata - rata dari K = 5,
maka kita akan membuat gambar tersebut menjadi blur. Perhatikan sintaksnya berikut ini.

Pada fungsi cv2.filter2D diatas, kita dapat memasukan parameter berupa

cv2.filter2D(gambar, kedalaman, kernel), dimana nilai kedalaman ini apabila -1, menandakan kita
menginginkan warna output yang sama seperti input. Perhatikan bahwa gambar siberian husky
tersebut terlihat lebih blur dibandingkan dengan gambar awalnya. Namun perhatikan juga, bahwa
tulisan ‘siberian husky’ lebih halus dibandingkan ketika kita tidak memberikan efek blur.
Selain kita mengaplikasikan filter kernel secara manual, kita bisa juga menggunakan fungsi
bawaan dari OpenCV. Fungsi yang digunakan adalah cv2.blur(). Pada fungsi ini, kita menuliskan
parameter cv2.blur(gambar, ukuran_kernel). Perhatikan penulisan sintaksnya berikut ini.

46
 Dengan menjalankan sintaks diatas, kita akan mendapatkan output gambar yang telah di blur
sebagai berikut.

Kita juga bisa mencoba jenis blur lain, seperti Gaussian Blur. Ketika kita melakukan efek
blur, tidak ada jenis blur yang dikatakan benar ataupun salah. Kita tinggal melihat mana efek blur
yang sesuai dengan yang kita inginkan. Kita akan mencoba untuk menggunakan Gaussian Blur
dengan memanggil fungsi cv2.GaussianBlur(), yang memiliki parameter sebagai berikut
cv2.GaussianBlur(gambar, ukuran_kernel, nilai_sigma). Nilai_sigma disini merupakan nilai
standar deviasi pada sumbu X. Apabila kita tidak menuliskan sumbu Y, maka nilai standar
deviasinya sama dengan sumbu X.

47
 Berikut ini merupakan contoh sintaks untuk mengaplikasikan Gaussian Blur.

Begitu sintaks tersebut dijalankan, berikut ini merupakan hasil gambar blur yang dihasilkan.

Kita juga bisa mencoba jenis blur lainnya, yaitu Median Blur. Fungsi yang digunakan
adalah cv2.medianBlur(). Parameter yang bisa kita berikan adalah
cv2.medianBlur(gambar,ukuran_kernel). Median Blur ini akan mengambil nilai median sesuai
dengan jumlah pixel yang kita tuliskan pada ukuran_kernel. Perhatikan penulisan sintaksnya
berikut ini.

48
 Begitu sintaks tersebut dijalankan, berikut ini merupakan hasil gambar blur yang dihasilkan.

Dengan menggunakan Median Blur, kita lihat bahwa tulisan ‘siberian husky’ sangat jelas
dan warna di sekitar tulisan tersebut terlihat lebih blur. Kita mendapati bahwa Median Blur dapat
menghilangkan noise dengan baik dibandingkan jenis blur lainnya.
Jenis blur lainnya yang dapat digunakan yaitu cv2.bilateralFilter, yang memiliki parameter
cv2.bilateralFilter(gambar, diameter, sigma_color, sigma_space).

49
 Bilateral Filter merupakan teknik blur dan smoothing yang digunakan untuk
menghilangkan noise. Perhatikan bahwa apabila kita menggunakan Median Blur atau jenis blur
lainnya, blur ini akan mengambil seluruh nilai di sekitar pixel acuan lalu akan mengambil nilai
mediannya, tanpa mempedulikan nilai tepi nya. Dengan menggunakan Bilateral Filter, kita dapat
mempertahankan nilai tepi ini sekaligus menghilangkan noise pada gambar. Perlu diperhatikan
bahwa Bilateral Filter ini memiliki kekurangan yaitu waktu komputasi yang cukup lama
dibandingkan blur lainnya. Perhatikan penulisan sintaksnya berikut ini.

Walaupun memiliki hasil yang menyerupai Median Blur, namun dapat kita perhatikan
Bilateral Filter ini memiliki warna tepi yang lebih tajam dibanding Median Blur.

50
 8. Image Enhancement
Image Enhancement merupakan sebuah teknik yang digunakan untuk memperbaiki kontras
dan kecerahan dari sebuah gambar. Salah satu metode yang cukup populer adalah penggunaan
histogram. Histogram dari sebuah gambar mencerminkan distribusi dari nilai pixel yang memiliki
kecerahan yang lebih tinggi, dan dapat digunakan untuk mengidentifikasi area pada gambar yang
memiliki kecerahan lebih rendah atau terlalu tinggi.
Teknik ini disebut dengan histogram equalization, dimana kita mendistribusikan ulang nilai
kecerahan dalam histogram. Histogram Equalization ini bekerja dengan cara menuliskan ulang
nilai pixel dalam gambar menjadi sebuah nilai baru yang memiliki distribusi yang sama dengan
pixel lainnya. Pada awalnya, kita akan menghitung histogram dari gambar tersebut lebih dahulu,
yang menunjukkan jumlah frekuensi tiap kecerahan pada pixel, lalu akan dinormalisasikan dengan
menggunakan fungsi distribusi kumulasi cumulative distribution function (CDF), yang
menggambarkan tiap probabilitas tiap nilai pixel pada gambar. Setelah CDF dihitung, nilai intensitas
yang baru akan didapatkan dengan menerapkan nilai ini pada pixel acuan sesuai dengan nilai dalam
CDF. Dengan demikian, nilai intensitas pada pixel acuan akan berubah sesuai dengan nilai intensitas
dari CDF.
Untuk menghitung nilai histogram tersebut, kita menggunakan fungsi dari OpenCV yaitu
cv2.calcHist(). Fungsi ini memiliki parameter cv2.calcHist(gambar, channel, mask, histSize,
range). Gambar merupakan gambar yang akan kita hitung histogramnya. Channel merupakan
channel warna pada color space pada gambar yang akan kita hitung histogramnya. Mask
merupakan parameter opsional, apakah kita akan menampilkan output yang sama dengan input atau
tidak. HistSize merupakan ukuran histogram, dimana nilai ini adalah 256 karena kita tahu jumlah
pixel tiap channel adalah 256 pixel. Range merupakan rentang dari nilai pixel tersebut. Setelah kita
mengetahui fungsi tersebut, kita akan mencoba untuk menuliskan sintaksnya dalam Python.

51
 Hal yang perlu diperhatikan diatas merupakan angka pada channels yang kita tuliskan, yang
merupakan indeks. Perhatikan bahwa pada OpenCV, kita membaca sebuah gambar memiliki color
space BGR. Color space BGR ini di indeks kan dengan B adalah indeks 0, G adalah indeks 1, dan R
adalah indeks 2. Ketika kita memanggil indeks 0 pada sintaks diatas, kita akan melihat histogram
dari channel biru.

Dapat kita lihat bahwa pada gambar siberian husky yang kita gunakan, channel biru banyak
muncul pada rentang pixel sekitar 30 - 40 dan 60 - 85. Kita ingat bahwa pada gambar siberian husky
yang kita punya, warna biru tidak menonjol, dan lebih banyak warna hijau, sehingga kita lihat
bahwa warna biru banyak muncul pada angka pixel rendah. Kita akan coba untuk melihat warna
hijau.

52
 Sintaks diatas akan menampilkan histogram berwarna hijau. Mari kita lihat output dari
histogram tersebut.

Pada channel berwarna hijau, kita lihat bahwa ada banyak pixel yang bernilai lebih tinggi
pada range 125 - 170. Kita ingat bahwa pada gambar siberian husky kita, banyak warna yang
berwarna hijau. Hal ini menyebabkan nilai pixel warna hijau akan memiliki frekuensi lebih tinggi.
Kita akan mencoba untuk membandingkan lagi dengan warna pixel pada warna merah. Perhatikan
sintaks berikut ini.

53
 Sintaks diatas akan menampilkan histogram berwarna merah. Mari kita lihat output dari
histogram tersebut.

Pada channel berwarna merah, kita lihat bahwa ada banyak pixel yang bernilai lebih tinggi
pada range 20 - 40 dan 115 - 140. Kita ingat bahwa pada gambar siberian husky kita, banyak warna
yang berwarna hijau. Hal ini menyebabkan nilai pixel warna merah yang tinggi tidak akan sebanyak
warna hijau, mungkin cenderung digunakan untuk perpaduan antar warna untuk menciptakan warna
lainnya.
Kita bisa juga menggunakan iterasi untuk mengeluarkan ketiga channel secara langsung agar
tidak perlu menggambarkannya satu persatu, berikut sintaksnya.

54
 Mari kita lihat hasil output dari sintaks diatas.

Kita lihat bahwa pada gambar diatas, kita menampilkan hasil output dari ketiga channel
tersebut, yang masing - masing digambarkan dengan warnanya masing - masing. Dari ketika
channel tersebut, kita lihat bahwa pixel tinggi didominasi oleh channel berwarna hijau. Terbukti
karena memang gambar siberian husky memiliki background yang dominan dengan warna hijau.
Setelah kita mengetahui bagaimana cara membaca histogram tersebut, kita akan mencoba
menerapkan teknik histogram ini untuk memperbaiki kontras dari sebuah gambar.

55
 Setelah kita memahami bagaimana cara kerja histogram yang dapat memberikan kita
gambaran mengenai jumlah pixel yang berada dalam sebuah gambar, kita akan mempelajari sebuah
teknik Image Enhancement yang menggunakan histogram, biasanya disebut sebagai Histogram
Equalization.
Histogram Equalization merupakan sebuah metode yang digunakan untuk menyesuaikan
kontras berdasarkan nilai histogram pada gambar. Cara ini dapat dicapai dengan menghitung nilai
akumulasi dari nilai penyebaran pixel tersebut, yang kita sebut juga sebagai cumulative distribution
function (CDF). Dari nilai CDF ini, kita akan mencoba untuk melakukan penyesuaian kembali
terhadap tiap pixel, dengan menggunakan CDF yang telah dibuat ini sebagai acuan, apakah kita
perlu meningkatkan nilai kontrasnya atau tidak. Dengan mendistribusikan ulang nilai intensitas
sebuah pixel terhadap nilai patokan CDF, kita menyesuaikan ulang grafik histogram tersebut dan
memperlebar bentuk histogram sehingga dapat mencakup seluruh rentang pixel.

Kita akan mencoba dahulu penggunaan Histogram Equalization dengan menggunakan

gambar hitam putih terlebih dahulu. Kita akan mengubah gambar siberian husky menjadi hitam
putih. Perhatikan sintaksnya berikut ini.

56
 Selain kita membandingkan gambar tersebut sebelum dan sesudah dilakukan enhancement,
kita juga akan menampilkan perbandingan dari nilai histogramnya. Perhatikan apabila kita
tampilkan output dari sintaks tersebut.

57
 Perhatikan bahwa dengan menggunakan fungsi cv2.equalizeHist() kita akan menampilkan
gambar yang memiliki intensitas dan kontras lebih terang dibandingkan gambar aslinya. Kita juga
melihat hasil dari histogramnya. Perhatikan bahwa pada gambar asli, kita melihat bahwa penyebaran
dari histogram tersebut tidak merata, namun pada gambar yang telah dilakukan enhancement, kita
melihat bahwa bentuk grafiknya berubah. Hal ini disebabkan karena fungsi cv2.equalizeHist() telah
mendistribusikan ulang nilai pixel dari gambar asli, sehingga pixel tersebut akan memiliki jumlah
frekuensi yang baru yang tersebar pada gambar.
Selain menggunakan pada gambar hitam putih, kita juga bisa menerapkan teknik tersebut
pada gambar berwarna. Kita akan mengubah warna tersebut menjadi HSV terlebih dahulu, karena
kita akan mengubah nilai “Value” dari warna HSV tersebut untuk dilakukan enhancement.
Perhatikan contoh berikut ini.

Dengan menjalankan sintaks diatas, kita akan mendapatkan perbandingan antara gambar asli
versi RGB dengan gambar hasil enhancement versi RGB. Perhatikan outputnya berikut ini.

58
 Dengan melakukan enhancement pada gambar tersebut, kita lihat bahwa pada sebelah kiri,
kita memiliki gambar asli yang terlihat lebih gelap dibandingkan gambar yang telah dilakukan
enhancement pada sebelah kanan. Gambar hasil enhancement akan lebih cerah dan memiliki kontras
lebih baik dibandingkan gambar asli. Kita akan mencoba untuk melihat hasil histogram dari kedua
gambar tersebut.

Ketika kita menjalankan sintaks diatas, kita akan mendapatkan perbandingan gambar
histogram berikut ini.

59
 Perhatikan bahwa pada data histogram pada gambar RGB memiliki penyebaran yang lebih
kecil dibandingkan dengan histogram pada gambar RGB hasil enhancement. Kita hanya mengecek
channel merah R saja, kita dapat mengecek channel lainnya untuk mengetahui bagaimana dampak
perubahan terhadap channel lain. Perhatikan gambar output berikut untuk channel G.

Kita juga akan mencoba untuk menggambarkan hasil histogram dari channel B juga.
Perhatikan gambar output berikut ini untuk channel B.

Sebagai kesimpulan, kita melihat bahwa dengan mengubah nilai histogram dengan teknik
Histogram Equalization, kita dapat memberikan ulang sebuah nilai pixel agar nilainya menjadi
lebih terdistribusi merata, agar gambar yang dihasilkan memiliki kontras dan intensitas yang lebih
terang.

60
Object Detection
Pada bagian ini, kita mulai memasuki salah satu aplikasi yang digunakan pada Computer
Vision. Pada bagian ini juga, kita akan membangun pembahasan kita dari mulai yang paling mudah
terlebih dahulu (deteksi sudut), sampai ke topik bahasan yang lebih dalam (deteksi wajah).
Object Detection merupakan salah satu dari aplikasi Computer Vision yang bertujuan
untuk mengidentifikasi dan mencari lokasi sebuah objek pada gambar. Selain bisa mengidentifikasi
gambar tersebut, komputer diharapkan juga dapat mengetahui posisinya pada gambar tersebut.
Dengan adanya metode ini, kita dapat dengan mudah mengaplikasikannya pada beberapa kehidupan
manusia sehari - hari, seperti pengemudi mobil otomatis, robotika, dan juga deteksi wajah. Dengan
menggunakan teknik ini juga, kita mengajarkan komputer bagaimana caranya mengolah informasi
menggunakan informasi visual.
Pada bagian ini, kita akan memulai untuk membahas topik yang lebih sederhana sampai kita
membangun sebuah algoritma deteksi objek yang lebih kompleks. Topik tersebut antara lain adalah :
1. Template Matching
2. Corner Detection
3. Edge Detection
4. Grid Detection
5. Contour Detection
6. Feature Matching
7. Watershed Algorithm
8. Face Detection
Kita akan memulai pembahasan kita dari algoritma yang lebih mudah dulu, yaitu
Template Matching.

61
 1. Template Matching
Metode ini merupakan metode paling sederhana dari object detection. Konsep yang dimiliki
pun sangat sederhana. Kita memiliki sebuah gambar contoh sebagai sebuah template dan patokan.
Ketika kita memiliki gambar lain, kita akan mencoba untuk membandingkan kedua gambar tersebut,
dan karena disini hanya membandingkan, kedua gambar tersebut harus benar - benar sama.
Pada OpenCV, kita memiliki beberapa fungsi bawaan yang dapat digunakan untuk
membandingkan, yaitu cv2.TM_CCOEFF, cv2.TM_CCOEFF_NORMED, cv2.TM_CCORR,
cv2.TM_CCORR_NORMED, cv2.TM_SQDIFF, dan cv2.TM_SQDIFF_NORMED. Sebagian
besar dari fungsi ini memanfaatkan korelasi dan juga perbedaan kuadratik yang digunakan untuk
menghitung selisih dari pixel pada kedua gambar. Kita tidak akan membahas fungsi tersebut satu per
satu, namun kita akan membandingkan performa dari keseluruhan fungsi tersebut, dan fungsi mana
yang memiliki performa yang terbaik dan terburuk untuk mendeteksi gambar kita. Perhatikan
contoh penulisan sintaksnya berikut ini.

62
 Kita akan mengambil gambar muka siberian husky kita dari Google Drive, dengan nama file
husky_face.png. Kita akan mencoba membandingkan dengan template dengan menggunakan salah
satu fungsi yang tersedia, yaitu cv2.TM_CCOEFF. Berikut ini penulisan sintaksnya.

Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan hasil seperti berikut ini.

Gambar tersebut merupakan sebuah peta panas (heatmap) dari gambar asli yang kita miliki.
Kegunaan dari heatmap adalah untuk menunjukkan perbedaan nilai pada sebuah data berdasarkan
warna, dimana warna yang lebih terang biasanya menunjukkan nilai data yang lebih tinggi
dibanding yang gelap. Warna yang terang berwarna kuning menunjukkan intensitas pixel yang
memiliki kemiripan dengan template yang kita miliki. Semakin tinggi intensitasnya, warna akan
menjadi kuning dan semakin rendah warna akan menjadi lebih gelap. Karena kita mengetahui
bahwa fungsi ini akan menghasilkan intensitas pixel yang tinggi dan rendah, kita bisa memanfaatkan
lokasi pixel tersebut untuk mencari lokasi nya pada gambar asli dengan menggambarkan persegi di
tempat tersebut, untuk memberikan kemiripan dengan bagian wajah yang kita miliki. Kita akan
menggunakan iterasi untuk memunculkan seluruh perbedaan dari seluruh fungsi tersebut. Kita
menggunakan fungsi eval yang akan membantu kita mengkonversi sebuah string menjadi sebuah
fungsi. Perhatikan penulisan sintaksnya berikut ini.

63
64
 Kita bisa melihat beberapa perbedaan metode dari template matching. Dari keseluruhan
metode yang ada, kita dapat melihat bahwa metode cv2.TM_CCORR memiliki posisi yang paling
mendekati dengan gambar template yang kita miliki. Dengan demikian, kita dapat menyimpulkan
bahwa untuk gambar siberian husky yang kita miliki, kita dapat menggunakan metode
cv2.TM_CCORR untuk mendapatkan hasil yang paling mendekati untuk menggunakan template
matching ini.

2. Corner Detection
Sebelum kita membahas lebih jauh mengenai Corner Detection, kita perlu mengetahui dulu
apa itu corner atau sudut. Berdasarkan definisi, sudut merupakan suatu bagian dimana pada bagian
tersebut memiliki dua arah yang dominan dan berbeda satu sama lain. Selain itu, kita bisa
menginterpretasikan juga bahwa sebuah sudut merupakan persimpangan antara dua bagian, dimana
satu tepi memiliki kecerahan yang berbeda.
Dua dari algoritma yang terkenal dalam menentukan corner detection yaitu Harris Corner
Detection dan Shi-Tomasi Corner Detection.
Harris Corner Detection bekerja dengan cara memindai sebuah gambar dan akan
menggeser pindaian tersebut perlahan - lahan, sampai menemukan sebuah tepian yang memiliki
perubahan yang beda di beberapa arah tersebut. Bagian ini akan kita sebut sebagai corner. Apabila
kita tidak menemukan bagian yang tidak berubah, kita dapat menyebutnya sebagai sebuah flat.
Apabila kita menemukan bagian yang berubah hanya pada satu arah saja, kita menyebutnya sebagai
edge. Untuk perbedaan antara flat, edge, dan corner, kita dapat melihat gambar berikut ini.

65
 Metode Shi-Tomasi Detection memiliki konsep yang serupa dengan Harris Corner
Detection. Perbedaan dari kedua hal ini hanyalah pada perhitungan model matematika yang
digunakan, dimana pada Harris Corner Detection kita menghitung sebuah kriteria dengan
menggunakan rumus berikut :

Sedangkan pada metode Shi-Tomasi Detection, kita memiliki rumus yang lebih sederhana
untuk menghitung sebuah kriteria, yaitu berikut ini :

Kita akan mencoba untuk membuat sebuah program dengan menggunakan Harris Corner
Detection untuk mendeteksi sudut. Kita menggunakan fungsi cv2.cornerHarris() untuk melakukan
ini. Parameter yang bisa kita berikan adalah cv2.cornerHarris(gambar, blockSize, ksize, k).
BlockSize merupakan jumlah cabang yang membentuk sudut. Ksize merupakan parameter Sobel
yang digunakan yang menentukan ukuran kernel, sedangkan K merupakan parameter yang
digunakan pada persamaan Harris. Kita juga menggunakan cv2.dilate() untuk memperbesar titik
sudut yang dideteksi agar mempermudah kita untuk melihat sudut yang dihasilkan dengan fungsi
Harris. Kita akan mewarnai titik corner tersebut dengan warna merah apabila nilai Harris nya
lebih besar dari 1% nilai maksimum pada persamaan Harris tersebut. Perhatikan sintaksnya berikut
dan juga hasil sintaks tersebut.

66
 Fungsi Harris yang kita buat mendeteksi bahwa ada beberapa bagian pada wajah siberian
husky tersebut yang merupakan sebuah corner. Hal ini wajar karena kita lihat pada gambar siberian
husky tersebut, bahwa gambar terfokus paling banyak pada bagian wajah, sehingga fungsi Harris
mendeteksi bahwa bagian wajah tersebut memiliki banyak corner.
Setelah ini, kita akan mencoba untuk menggunakan Shi-Tomasi Corner Detection. Fungsi
yang digunakan untuk ini adalah cv2.goodFeaturesToTrack(), yang memiliki nama berbeda dari
nama teknik yang digunakan. Fungsi ini memiliki beberapa parameter yang dapat diberikan, yaitu
cv2.goodFeaturesToTrack(gambar, jumlah_corner_max, quality_level,
jarak_minimum_pixel). Jumlah corner akan menentukan ada berapa banyak maksimum jumlah
corner yang akan kita tampilkan. Quality level menentukan nilai eigen value yang digunakan pada
perhitungan fungsi ini, namun kita memiliki beberapa nilai default yang baik, seperti 0,01. Jarak
minimum pixel merupakan jarak minimum antar corner dihitung dengan pixel. Kita akan
membangun pembentukan corner dengan menggunakan gambar grayscale, lalu menerapkannya
pada gambar kita yang berwarna. Perhatikan bagaimana cara penulisan sintaksnya berikut ini.

67
 Setelah kita memanggil fungsi cv2.goodFeaturesToTrack(), kita akan mengubah nilainya
menjadi sebuah integer. Kita akan melakukan iterasi untuk tiap nilai pada corners lalu
menggambarkan lingkaran pada tiap titik pixel x dan y tersebut. Ketika kita menjalankan sintaks
diatas, kita akan mendapatkan hasil seperti berikut ini.

68
 Dapat kita lihat bahwa dengan metode Shi-Tomasi kita memiliki lebih banyak sudut yang
terdeteksi. Namun kekurangan dari metode ini adalah kita perlu membuat sendiri fungsi lingkaran
yang digunakan untuk menandai sudut tersebut, sedangkan pada fungsi Harris kita tidak perlu
membuat lingkaran tersebut sendiri. Kita dapat lihat dengan menggunakan metode Shi-Tomasi, kita
mendapatkan lebih banyak sudut, namun apakah metode ini lebih baik dibandingkan dengan fungsi
Harris, kembali lagi ke bagaimana cara kita dan kriteria yang diinginkan untuk mendeteksi sudut
tersebut.

3. Edge Detection
Edge Detection merupakan salah satu aplikasi dari image processing dan object detection
yang cukup populer untuk digunakan, karena metode ini dapat mendeteksi tepian pada gambar
digital. Dengan adanya metode ini, kita bisa mengidentifikasi batasan atau tepi dari sebuah objek
pada gambar, sehingga metode ini yang umum lebih banyak digunakan untuk object detection,
segmentasi, dan feature extraction. Ada beberapa teknik yang dapat digunakan untuk Edge
Detection ini, beberapa diantaranya adalah :
1. Sobel Edge Detection
2. Canny Edge Detection
3. Laplacian Edge Detection
4. Zero Crossing Edge Detection
5. Robert Edge Detection
6. Prewitt Edge Detection
Meskipun kita memiliki beberapa macam metode Edge Detection, Canny Edge
Detection merupakan metode yang paling populer untuk digunakan karena memiliki akurasi yang
lebih baik dibanding metode lainnya. Kita akan mencoba untuk membahas masing - masing dari
jenis Edge Detection tersebut.

a. Sobel Edge Detection

Sobel Edge Detection menggunakan sebuah kernel yang di-konvolusikan dengan gambar
untuk menghitung nilai gradien pada sumbu x dan y. Kernel yang dapat digunakan dapat berukuran
3x3 ataupun 5x5 dengan nilai kernel berikut ini :

69
 Untuk mengaplikasikan metode Sobel ini, pertama kita akan membuat gambar
tersebut menjadi sebuah gambar abu - abu (grayscale). Setelah itu, kedua kernel tersebut akan
dikonvolusikan dengan gambar kita. Setelah melakukan konvolusi terhadap gambar, kita akan
mendapatkan 2 gambar, dimana yang satu berupa perubahan nilai X (horizontal) dan satu berupa
perubahan nilai y (vertikal) pada gambar. Jenis gambar ini juga disebut dengan gambar gradien.
Nilai magnituda dari gradien ini akan dihitung, lalu sebuah nilai threshold akan
diberikan pada gambar gradien tersebut, dimana pixel dengan nilai lebih tinggi dari threshold
tersebut dianggap sebagai tepi, sedangkan sisanya akan dianggap bukan tepi. Berikut merupakan
contoh penulisan sintaksnya.

70
 Pada sintaks diatas, kita membuat matriks Sobel menggunakan cv2.Sobel() dimana kita bisa
menuliskan parameter cv2.Sobel(gambar, ddepth, kernel X, kernel Y, ukuran_kernel). Untuk
ddepth sendiri kita bisa melihat dokumentasi Sobel untuk parameter yang akan diisikan.

Dengan menjalankan sintaks tersebut, kita akan mendapatkan output seperti berikut ini.

b. Canny Edge Detection

Metode Canny Edge Detection merupakan metode yang umum digunakan dalam algoritma
Edge Detection. Algoritma ini dikembangkan oleh John Canny pada tahun 1986 dan bekerja
dengan cara mencari intensitas gradien didalam gambar.
Langkah yang dilakukan adalah dengan menerapkan filter Gaussian untuk membuang noise,
lalu menghitung kernel gradien dengan menggunakan operator Sobel. Berikutnya, kita mencari nilai
maksimum dalam arah gradien tersebut dan menurunkan seluruh nilai pixel yang bukan merupakan
nilai maksimum. Secara tidak langsung, fungsi tersebut akan menciptakan threshold tinggi dan
rendah. Pixel dengan nilai gradien lebih tinggi dari threshold akan dianggap tepian kuat, sedangkan
sisanya dianggap tepian lemah. Terakhir, kedua jenis tepian tersebut akan digabungkan jadi satu.

71
 Algoritma ini banyak digunakan dalam aplikasi pada Image Processing ataupun Object
Detection, dan merupakan yang paling umum digunakan karena tingkat akurasinya yang baik,
dibandingkan dengan metode lainnya. Berikut ini merupakan contoh penulisan dari sintaks Canny
Edge Detection.

Kita menggunakan Gaussian Blur disini untuk melakukan smoothing terhadap gambar
tersebut untuk membuang noise nya. Ingat bahwa parameter yang bisa kita berikan adalah
cv2.GaussianBlur(gambar, ukuran_kernel, sigma_X).
Setelah menerapkan smoothing, kita bisa menggunakan fungsi bawaan dari OpenCV, yaitu
cv2.Canny(), yang didalamnya sudah ada operator Sobel. Fungsi ini memiliki beberapa parameter
yang bisa kita berikan, yaitu cv2.Canny(gambar, threshold_1, threshold_2). Ingat bahwa pada
bagian teori, kita membuat dua threshold pada Canny, dimana nilai threshold ini akan menjadi
batas untuk menentukan mana tepian kuat dan tepian lemah. Setelah itu, kita dapat menampilkan
kedua gambar tersebut. Perhatikan hasil keluaran dari sintaks tersebut apabila kita menjalankan
fungsi tersebut.

72
 c. Laplacian Edge Detection
Metode Laplacian Edge Detection juga merupakan salah satu metode Edge Detection yang
umum digunakan dalam image processing ataupun object detection. Metode ini bekerja dengan
menghitung derivatif kedua dari sebuah gambar dan mengidentifikasi area yang memiliki perubahan
sangat besar dari intensitasnya. Ciri ini merupakan ciri sebuah tepian, dimana pada tepian kita
biasanya akan memiliki nilai pixel dengan intensitas yang lebih tinggi dibandingkan nilai pixel
lainnya.
Operator Laplace sendiri merupakan operator matematika yang digunakan untuk
menghitung derivatif tersebut. Biasanya operator ini digambarkan dalam sebuah kernel berukuran
3x3 yang diaplikasikan pada tiap pixel pada gambar. Biasanya, operator ini diaplikasikan setelah
kita menerapkan Gaussian Blur pada gambar untuk mengurangi noise. Setelah itu kita membuat
sebuah threshold agar gambar tersebut hanya berisikan warna hitam dan putih, baru setelah ini kita
menerapkan operator Laplace.
Walaupun metode ini tergolong efektif untuk mendeteksi tepian, metode ini juga dapat tidak
sengaja mendeteksi sebuah noise menjadi sebuah tepian. Hal ini dapat terjadi karena operator
Laplace sangat sensitif terhadap perubahan frekuensi yang dapat disebabkan oleh noise. Oleh
karena itu, operator ini baru akan efektif apabila kita menerapkan teknik smoothing terlebih dahulu,
atau menjadi pelengkap bagi teknik Edge Detection lainnya. Berikut ini merupakan contoh
penulisan sintaks untuk menggunakan metode ini.

73
 Pada sintaks diatas, kita menerapkan Gaussian Blur dulu untuk mengurangi noise. Setelah
itu, kita bisa menerapkan operator Laplace dengan menggunakan fungsi cv2.Laplacian().
Parameter yang bisa kita berikan adalah cv2.Laplacian(gambar, ddepth). Hasil dari operator
Laplace ini akan kita buat menjadi integer, karena apabila kita menghitung sebuah derivatif ada
kemungkinan bahwa nilai matematika yang kita dapat merupakan pecahan. Setelah itu, kita akan
menerapkan metode Canny Edge Detection, dengan menerapkan threshold terlebih dahulu sesuai
teorinya. Setelah itu, kita akan menerapkan metode Canny Edge Detection pada gambar yang
sudah diberlakukan operator Laplace tersebut. Setelah itu, kita bisa melihat perbandingan dari
apabila kita berlakukan operator Laplace dengan menggunakan Canny Edge Detection biasa.
Perhatikan hasil dari keluaran sintaks tersebut berikut ini.

74
 Dari hasil gambar diatas, kita melihat dengan menerapkan operator Laplace, kita
mendapatkan hasil tepian yang kurang jelas dibandingkan dengan menggunakan Canny Edge
Detection saja. Kita bisa mencoba untuk mengubah nilai threshold menyesuaikan dengan hasil yang
kita inginkan, untuk mendapatkan hasil tepian yang lebih jelas lagi.

d. Zero Crossing Edge Detection

Metode Zero Crossing Edge Detection ini merupakan metode edge detection untuk
mendeteksi tepian pada gambar dengan mendeteksi adanya perubahan sebuah nilai ketika melewati
nilai 0 (zero crossing) pada derivatif tingkat kedua pada gambar. Metode ini dapat digunakan untuk
mendeteksi tepian pada gambar tanpa ada gangguan oleh noise, dikarenakan metode perpotongan
titik nol ini lebih stabil dibandingkan nilai pada derivatif kedua. Algoritma ini bekerja dengan cara
mengaplikasikan smoothing dulu pada gambar untuk mengurangi noise, lalu kita menggunakan
operator Laplace untuk menghitung derivatif tingkat kedua pada gambar. Gambar Laplace ini akan
dicek untuk mencari nilai intensitas pixel yang berubah, yang menandakan adanya zero crossing.
Nilai ini akan ditandai sebagai sebuah tepi pada hasil akhirnya.
Metode Zero Crossing Edge Detection ini sangat berguna untuk mendeteksi tepian yang
memiliki noise sangat banyak, karena memang metode ini tidak begitu sensitif terhadap noise
dibandingkan dengan metode edge detection lainnya. Kita bisa menggunakan metode ini untuk
gambar yang memiliki kontras yang sangat tinggi, karena dapat dengan mudah mendeteksi tepian.
Perhatikan contoh sintaks berikut ini.

75
 Pada sintaks diatas, kita pertama akan menerapkan Gaussian Blur untuk mengurangi
jumlah noise, lalu menerapkan operator Laplace untuk mendapatkan nilai derivatif kedua. Untuk
menerapkan metode zero crossing, kita tidak menggunakan fungsi bawaan, namun kita akan
menggunakan iterasi untuk menandakan titik-titik yang dianggap sebagai sebuah tepi. Kita akan
membuat sebuah matriks baru berisi angka 0 sebesar matriks pada gambar Laplace kita yang
dinamakan edges. Apabila nilai pixel pada gambar Laplace kita memiliki nilai intensitas yang
kontrasnya tinggi dan lebih tinggi dari threshold, maka kita akan mengubah nilai pixel pada matriks
edges menjadi angka 255 yang berarti warna putih. Kita akan melakukan iterasi ini untuk seluruh
pixel pada gambar. Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan keluaran
sebagai berikut.

76
 e. Robert Edge Detection

Robert Edge Detection merupakan metode yang simpel dan cepat untuk digunakan untuk
mendeteksi tepian yang menggunakan sebuah kernel berukuran 2x2 untuk mendeteksi tepian pada
sebuah gambar. Kita menggunakan 2 macam kernel, yaitu kernel untuk arah X dan arah Y. Kedua
kernel ini disebut juga sebagai Robert’s Cross Operator dan bentuknya adalah seperti berikut ini :

‘Gx’ dan ‘Gy’ merupakan filter gradien horizontal dan vertikal. Operator ini bekerja dengan
cara menghitung perbedaan pixel antara pixel arah diagonal dalam ukuran 2x2. Hasil selisihnya
tersebut kemudian akan dibandingkan dengan sebuah nilai threshold untuk menciptakan sebuah
gambar biner hitam putih yang membentuk tepian. Algoritma ini sangat sederhana dan bekerja
dengan cepat dan juga sangat efisien. Namun karena metode ini hanya membandingkan selisih pixel
saja, maka algoritma ini tidak akan seakurat algoritma lainnya. Mungkin untuk gambar yang
memiliki kontras tinggi akan bekerja dengan baik, namun apabila kontras rendah, maka dapat
menimbulkan ketidakakuratan. Perhatikan contoh sintaks dari metode ini berikut ini.

77
 Perhatikan bahwa pada sintaks diatas, kita pertama membuat kernel Robert dahulu, lalu kita
menghitung gradien dari hasil konvolusi kernel dengan gambar. Kita akan menghitung magnitude
berdasarkan akar kuadratik dari penjumlahan antar grad_x dan grad_y. Disini kita menetapkan nilai
threshold adalah 8. Lalu sama seperti pada metode zero crossing, disini kita akan membuat sebuah
matriks 0 baru seukuran gambar hasil konvolusi kita. Kita akan membandingkan apabila nilai pixel
tersebut memiliki nilai gradien yang lebih besar dibandingkan dengan nilai threshold, maka kita
akan menjadikan pixel tersebut 255 atau warna putih. Ketika kita mengaplikasikan kondisi ini untuk
seluruh pixel pada edges, kita akan melihat titik putih yang menjadi sebuah tepian pada gambar kita
yang baru. Perhatikan hasil keluaran dari sintaks diatas.

78
 Dengan menggunakan metode Robert, kita lihat bahwa sintaks kita dapat menghasilkan
nilai tepi. Namun kita lihat bahwa dengan kontras yang rendah pada gambar siberian husky, kita
lihat banyak sekali noise yang dihasilkan. Seperti yang telah dijelaskan pada teori bahwa metode ini
sangat rentan terhadap noise dan dapat menimbulkan ketidakakuratan.

f. Prewitt Edge Detection

Metode Prewitt Edge Detection ini merupakan metode lain dari edge detection yang cukup
populer digunakan dalam object detection. Metode ini menggunakan kernel berukuran 3x3
berjumlah 2, dimana yang satu digunakan untuk mendeteksi tepian horizontal dan yang satu lagi
digunakan untuk mendeteksi tepian vertikal. Berikut bentuk kernel tersebut :

Pada metode ini, kita akan melakukan konvolusi antar kernel tersebut dengan gambar untuk
menghitung masing - masing nilai gradien pada arah horizontal maupun vertikal. Magnitude yang
dihasilkan ini akan kemudian dihitung dengan menggunakan akar kuadratik penjumlahan untuk
menghitung gradien secara keseluruhan. Kita akan membandingkan nilai gradien tersebut dengan
sebuah threshold, lalu pixel yang memiliki gradien lebih tinggi dari threshold akan ditandai sebagai
sebuah tepian.

79
 Secara singkat, metode Prewitt ini memiliki cara kerja yang sama dengan metode Robert.
Perbedaan mendasar adalah ukuran kernel yang digunakan. Apabila pada metode Robert kita
menggunakan kernel berukuran 2x2, maka pada metode Prewitt kita menggunakan kernel
berukuran 3x3. Cara kerja dan konsep selebihnya merupakan cara yang sama seperti yang telah kita
lakukan pada metode Robert. Perhatikan penulisan sintaksnya berikut ini.

Bentuk penulisan dari sintaks tersebut sama persis dengan apa yang kita gunakan saat
membuat sintaks metode Robert. Kita hanya perlu mengganti kernel tersebut. Apabila sintaks
tersebut kita jalankan, kita akan mendapatkan keluaran seperti berikut ini.

80
 Sebagai kesimpulan, dari keenam macam jenis metode Edge Detection yang sudah kita
lakukan, kita melihat bahwa performa untuk metode Canny masih jauh lebih baik dibandingkan
dengan metode lainnya, dimana pada beberapa metode kita masih bisa melihat banyak sekali noise
yang dianggap sebagai tepian. Namun bukan berarti metode Canny selalu yang paling baik untuk
melakukan Edge Detection ini. Kita dapat selalu bermain dengan parameter threshold dan juga
parameter fungsi yang digunakan, untuk mendapatkan hasil yang optimal dengan menggunakan
metode selain Canny.

4. Grid Detection
Grid Detection merupakan sebuah teknik yang umum digunakan untuk mengetahui struktur
dari sebuah benda ataupun objek dalam sebuah gambar. Umumnya, aplikasi ini dapat dilakukan
untuk melakukan kalibrasi terhadap perangkat elektronik yang kita gunakan. Bayangkan apabila kita
memiliki sebuah kamera digital, dan kita tidak melakukan kalibrasi terhadap lensa. Kita cenderung
berkemungkinan untuk mendapatkan hasil gambar yang blur dan tidak kontras.
Dengan menggunakan Grid Detection ini, diharapkan kita mendapatkan struktur sebuah
benda dan menyimpan informasi tersebut. Sehingga apabila kita memiliki gambar yang sama lagi
untuk dilakukan pengujian, kita bisa menilai apakah metode yang kita gunakan sudah mampu untuk
mendapatkan hasil serupa dengan informasi yang telah disimpan tersebut.
Kita akan mencoba untuk mendeteksi struktur gambar tersebut, dan kali ini kita akan
menggunakan gambar berbeda, yaitu menggunakan gambar papan catur. Kita akan melihat apakah
metode yang digunakan mampu untuk mendeteksi struktur dari papan catur tersebut. Perhatikan
penulisan sintaksnya berikut ini.

81
 Kita akan menggunakan gambar yang berbeda kali ini, yang berupa papan catur. Fungsi yang
digunakan yaitu cv2.findChessboardCorners() merupakan fungsi yang umum digunakan untuk
melakukan kalibrasi. Kita bisa memberikan parameter yaitu cv2.findChessboardCorners(gambar,
ukuran). Perhatikan ukuran yang kita masukan disini adalah 7x7 dan bukan 8x8. Terkadang
OpenCV tidak bisa mendeteksi ujung sudut ke - 8 dikarenakan sudut papan catur tersebut terhimpit
oleh gambar, karena itu jumlah sudut maksimum yang kita miliki hanyalah 7. Fungsi ini akan
menghasilkan 2 output, yaitu found dan corners. Found merupakan sebuah data boolean True atau
False yang bernilai True apabila menemukan sudut dan False apabila tidak menemukan sudut.
Apabila found bernilai True, maka variabel Corners akan mengembalikan nilai array yang
menunjukkan posisi sudut yang terdeteksi pada gambar.
Setelah itu, nilai ini akan kita berikan kepada fungsi cv2.drawChessboardCorners() yang
berfungsi untuk menggambar sudut pada gambar kita. Parameter yang dapat diberikan adalah
cv2.drawChessboardCorners(gambar, ukuran, array_sudut, boolean_found). Ketika kita
menampilkan keluaran dari fungsi ini, maka kita akan memiliki gambar yang sudah diberikan titik
sudut secara serial. Dari titik-titik sudut berwarna tersebut yang digabungkan, kita dapat melihat
sebuah struktur dan pola dalam gambar tersebut. Perhatikan hasil keluaran dari fungsi tersebut
berikut ini.

82
 Gambar yang dihasilkan tersebut memiliki sudut yang berwarna. Sudut tersebut membentuk
garis dari ujung satu baris ke baris yang lainnya, menandakan bahwa sudut tersebut membentuk
sebuah struktur. Ketika kita mengubah orientasi dari gambar tersebut, karena fungsi tersebut
digunakan untuk kalibrasi, maka kita akan tetap mendapatkan struktur warna dan lokasi sudut yang
sama. Perhatikan perbandingan gambar tersebut apabila kita mengubah orientasi dari sebuah gambar
papan catur.

83
 5. Contour Detection
Contour Detection merupakan analisa object detection pada sudut yang nilainya
continuous. Definisi dari contour sendiri merupakan sebuah bagian melengkung pada gambar yang
membentuk sebuah nilai titik continuous, yang memiliki warna ataupun intensitas yang sama.
Contour ini berguna untuk analisa sebuah bentuk pada benda dan juga object detection dan juga
recognition. Dalam OpenCV, kita memiliki sebuah fungsi bawaan yaitu cv2.findContours() yang
digunakan untuk mencari perbedaan kontur antar gambar. Parameter yang bisa kita berikan pada
fungsi ini adalah cv2.findContours(gambar, mode, method). Terdapat beberapa mode dan
method yang dapat digunakan untuk mengisi parameter tersebut. Berikut ini merupakan informasi
mengenai mode dan method yang diambil langsung dari dokumentasi OpenCV.

Mode

84
Method

Setelah mengetahui fungsi tersebut dan bagaimana cara kita memasukan parameter ke
dalamnya, kita akan mencoba untuk membuat sintaks Python. Kita akan menggunakan gambar yang
memiliki perbedaan kontur yang sangat kontras untuk mempermudah pemahaman kita mengenai
metode Contour Detection yang akan kita pelajari ini. Perhatikan contoh penulisan sintaksnya
berikut ini.

Kita akan mengambil sebuah gambar yin & yang berikut ini, lalu kita akan mencoba
mengecek apakah OpenCV dapat mendeteksi kontur dari gambar tersebut. Apabila kita
menampilkan gambar tersebut, maka kita akan mendapatkan gambar berikut ini.

85
 Untuk mempermudah pengerjaan, kita hanya akan menggunakan deteksi kontur dengan
gambar berwarna abu - abu saja. Mari kita lihat gambar versi grayscale hasil keluaran sintaks
tersebut.

Setelah kita mengetahui bentuk gambar kita, kita akan mencoba untuk membuat deteksi
kontur tersebut menggunakan fungsi yang telah kita bahas sebelumnya.

86
 Fungsi diatas cv2.findContours akan kita gunakan untuk mencari kontur dari gambar yin &
yang tersebut. Kita menggunakan mode cv2.RETR_CCOMP yang berarti kita akan mengambil
seluruh kontur secara komplit (completed) yang berarti kita mengambil seluruh kontur internal dan
kontur eksternal. Perhatikan bahwa dalam sebuah gambar, kita memiliki kontur yang disebut
eksternal (apabila bersentuhan dengan background) dan juga kontur yang disebut internal (apabila
bersentuhan dengan foreground). Dengan mode ini, kita akan mengambil seluruh kontur tersebut.
Kita juga menggunakan method cv2.CHAIN_APPROX_SIMPLE yang mengambil seluruh sudut
kontur yang mungkin. Output dari fungsi ini merupakan dua variabel yang dapat kita kategorikan
sebagai contours dan hierarchy.
Variable contours berisikan sebuah tuple dari array yang berisi posisi dari kontur tersebut
berada. Apabila kita mengecek tuple tersebut, kita melihat jumlahnya sesuai jumlah kontur yang
dapat ditemukan oleh fungsi cv2.findContours.

87
 Angka yang berada dalam tiap array tersebut merupakan posisi dari tiap kontur yang dapat
ditemukan oleh fungsi. Kita memiliki sebuah variabel lagi, yaitu hierarchy. Hierarchy ini
merupakan sebuah array yang berisikan informasi mengenai kontur tersebut.

Dalam hierarchy tersebut, kita memiliki informasi yang memuat keterangan mengenai
kontur. Bagian terpenting adalah indeks yang terakhir, yang berisikan angka -1 dan 1. Indeks
terakhir ini menunjukkan apakah kontur tersebut merupakan kontur internal atau eksternal (-1).
Dalam kasus gambar yang kita miliki, fungsi kita hanya dapat mendeteksi adanya 2 macam kontur
saja. Namun pada kasus sebenarnya, kita dapat memiliki nilai lebih dari 2, apabila kita memiliki
lebih dari 2 kontur eksternal.
Untuk dapat memanggil hierarchy dan contours tersebut, kita akan membuat sebuah array
baru berisikan nilai nol, untuk membuat visualisasi mengenai kontur kita. Perhatikan penulisan
sintaksnya berikut ini.

Pada mulanya, kita akan membuat sebuah array berisikan nol dengan mengambil bentuk
dari gambar asli kita. Setelah itu kita akan mencoba untuk memvisualisasikan hasilnya array
external_contours yang kita miliki.
88
 Kita akan melakukan iterasi sebanyak jumlah hierarchy yang kita miliki, karena hierarchy
tersebut yang menggambarkan jumlah macam kontur yang kita miliki. Kita akan mengecek nilai
indeks terakhir dari tiap hierarchy, apabila nilainya adalah -1, kita akan memanggil fungsi
cv2.drawContours() yang bertujuan untuk melukiskan kontur kita pada array baru. Parameter yang
bisa dimasukan pada fungsi ini adalah cv2.drawContours(gambar, kontur, index_kontur,
warna_kontur, ketebalan). Kita akan melakukan ini berulang - ulang sejumlah iterasi yang dapat
dilakukan. Ketika kita melihat hasil dari external_contours, kita mendapati bahwa kini
external_contours tidak lagi seluruhnya berwarna hitam (array berisi nol akan menampilkan
gambar berwarna hitam).

89
 Perhatikan gambar tersebut. Apabila kita komparasikan dengan gambar aslinya, maka
terdapat perbedaan signifikan

Gambar asli kita merupakan yang sebelah kiri, sedangkan yang sebelah kanan merupakan
gambar yang digambar oleh fungsi kontur kita. Karena kita menuliskan kita hanya ingin
menggambar apabila hierarchy = -1 atau yang berarti adalah kontur eksternal, maka perhatikan
warna bulat hitam pada gambar asli tidak akan tergambar pada gambar kontur kita. Hal ini
dikarenakan warna bulat hitam tersebut tidak bersentuhan langsung dengan warna background hitam
sehingga fungsi kontur kita menganggap warna bulat hitam tersebut merupakan kontur internal.
Dengan menggunakan fungsi yang sama, kita juga bisa melihat hasil kontur internal yang
digambarkan. Perhatikan sintaksnya berikut ini.

Karena kita ingin menampilkan kontur internal kita, yang merupakan warna bulat hitam, kita
akan mengubah backgroundnya menjadi warna putih dulu, dengan membuat sebuah array yang
dikalikan dengan angka 255. Kita juga mengubah warna pada fungsi cv2.drawContours() menjadi
0 untuk menampilkan warna hitam. Perhatikan hasil keluaran dari sintaks tersebut.

90
 Perhatikan bahwa sekarang kita menggambar kontur internal kita pada variabel
internal_contours. Apabila output ini kita bandingkan dengan gambar aslinya, maka kita memiliki
lokasi warna bulat hitam yang cocok dengan posisi pada gambar aslinya. Perhatikan gambar berikut
ini.

Perhatikan bahwa pada kontur internal, apabila kita memiliki kontur internal lainnya, dan
pada hierarchy kita mendapatkan nilai lebih dari angka -1 dan 1, kita bisa menuliskan angka
tersebut pada fungsi kondisi saat melakukan iterasi, untuk memilih kontur mana yang akan kita
gambarkan pada array baru kita.

91
 6. Feature Matching
Kita sebelumnya sudah membahas mengenai template matching. Template matching
memindai gambar dan mencari bagian yang mirip dari gambar yang kita berikan dengan gambar
yang telah ada sebelumnya. Namun, metode template matching ini memiliki kelemahan bahwa kita
perlu memiliki gambar yang sama persis untuk metode ini dapat bekerja. Pada keadaaan sebenarnya,
kita sangat sulit untuk menemukan gambar yang sama persis dengan gambar yang kita miliki
sebelumnya.
Feature Matching merupakan metode dimana kita akan mengekstrak beberapa fitur yang
penting dari sebuah gambar yang diberikan, menggunakan penggabungan beberapa metode dari
corner, edge, dan contour detection. Digabungkan dengan menggunakan sedikit perhitungan, kita
akan mencari seluruh bagian yang mirip pada gambar yang diberikan, dengan gambar yang kita
miliki sebelumnya. Dengan demikian, kita tidak memerlukan gambar kedua yang sama persis untuk
dapat melakukan hal ini.
Untuk mengerjakan feature matching ini, kita akan mencoba 2 macam metode yang ada,
yaitu Brute Force Matching dan FLANN-based Matcher. Kita akan menggabungkannya dengan
algoritma yang digunakan juga untuk melakukan feature detection/extraction seperti SIFT dan
ORB Descriptors.
Kita akan membahas ketiga metode ini masing - masing untuk mengetahui
bagaimana cara tiap metode tersebut bekerja untuk mendeteksi fitur dari sebuah gambar.

a. Brute-Force Matching dengan ORB Descriptors

Konsep dari Brute-Force sendiri sangat sederhana. Brute-Force (BF) mengambil deskriptor
dari sebuah fitur pada gambar pertama, lalu dipasangkan dengan seluruh fitur pada gambar kedua
dengan menggunakan perhitungan jarak. Nilai yang terdekat akan dikembalikan. Fungsi yang
digunakan adalah cv2.BFMatcher(). Parameter yang dapat diberikan ada dua, yaitu
cv2.BFMatcher(normType, variabel_crosscheck). NormType disini memberikan kita gambaran
bagaimana kita akan mengukur jarak antar kedua gambar tersebut.

92
 Secara default, normtype adalah cv2.NORM_L2. Tipe ini bagus digunakan untuk metode
SIFT ataupun SURF. Untuk gambar yang bersifat biner seperti ORB, BRIEF, BRISK, dan lainnya,
kita menggunakan cv2.NORM_HAMMING, dimana kita menggunakan Hamming distance
sebagai metode pengukuran.
Parameter kedua merupakan variabel boolean Cross Check, dimana sebagai default nilainya
False. Apabila True, fungsi tersebut hanya mengembalikan nilai yang sama saja yang merupakan
best match.
ORB (Oriented Fast and Rotated BRIEF) merupakan metode yang menggabungkan metode
FAST (Features from Accelerated Segment Test) yang digunakan untuk corner detection dan metode
BRIEF descriptor (Binary Robust Independent Elementary Features) yang digunakan untuk
mencari pixel yang memiliki fitur yang paling penting. Kita akan mencari dahulu keypoint dan juga
descriptor yang akan kita gunakan dengan metode ORB ini, sehingga dapat kita cari jaraknya
dengan menggunakan fungsi cv2.BFMatcher kita. Perhatikan contoh penulisan sintaksnya berikut
ini.

Kita akan menggunakan gambar siberian husky yang biasa kita gunakan. Perhatikan apabila
kita menjalankan sintaks diatas, kita akan mendapatkan gambar berikut.

93
 Kita juga akan menggunakan gambar siberian husky lain yang akan kita gunakan sebagai
gambar untuk menguji apakah fungsi kita berjalan dengan baik atau tidak. Perhatikan sintaks
berikut.

Setelah kita memiliki kedua gambar tersebut, dimana gambar siberian husky yang biasa kita
gunakan akan dipakai sebagai gambar untuk melatih fungsi kita, dan gambar siberian husky diatas
yang digunakan untuk menguji fungsi kita, kita akan membuat kedua gambar tersebut menjadi
grayscale.

Setelah kita memiliki kedua gambar tersebut, kita pertama akan membuat komponen dari
ORB dahulu dari gambar tersebut. Kita membuatnya dengan menggunakan kelas
cv2.ORB_create(). Gambar tersebut akan kita buat kedalam model ORB tersebut, lalu kita akan
mencari keypoint dan juga descriptor nya masing - masing dengan menggunakan fungsi
cv2.ORB_create().detectAndCompute(). Fungsi ini akan menghasilkan dua output, yaitu nilai
keypoint dan juga descriptor. Setelah itu kita akan membuat fungsi cv2.BFMatcher untuk
memasangkan tiap descriptor. Perhatikan contoh penulisan sintaksnya berikut ini.

94
 Perhatikan bahwa nilai des1 dan des2 berupa sebuah array yang menggambarkan fitur yang
dianggap sebagai keypoint.

Karena gambar kita merupakan gambar biner grayscale, kita menggunakan

cv2.NORM_HAMMING sebagai normtype. Kita juga menginginkan fungsi tersebut
mengembalikan nilai best match, sehingga parameter crossCheck akan kita jadikan True.
Setelah itu, kita akan membuat fungsi BFMatcher. Kita akan memasangkan kedua
descriptor pada kedua gambar tersebut dengan menggunakan fungsi match. Kita juga akan
mengurutkan nilai array dari output match tersebut berdasarkan jarak. Terakhir, kita juga akan
menggambarkan ulang fitur yang sama menggunakan fungsi cv2.drawMatches, yang memiliki
parameter cv2.drawMatches(gambar1, keypoint1, gambar2, keypoint2, hasil_match,
masking?, flags).

95
 Flags merupakan cara fungsi tersebut untuk menggambarkan sebuah keypoint pada gambar
output. Terdapat beberapa opsi yang dapat dipilih, perhatikan definisi berikut ini :

Perhatikan berikut ini bagaimana cara kita membuat sintaks untuk membuat BFMatcher
tersebut.

Pada hasilnya, kita hanya akan menggambarkan 10 kemiripan pertama yang ditemukan oleh
fungsi tersebut. Apabila kita menjalankan bagian sintaks tersebut, kita akan mendapatkan output
gambar kita yang sudah dipasangkan berdasarkan fitur yang ditemukan. Perhatikan output berikut
ini.

96
 Kita lihat bahwa sekarang gambar kita telah dipasangkan satu sama lain. Kita lihat bahwa
dengan menggunakan metode ini, fungsi BF dengan ORB kita tidak memetakan fitur pada kedua
gambar dengan akurat dan tepat. Walaupun keduanya merupakan gambar siberian husky yang sama,
namun metode BF dengan ORB ini tidak dapat memetakan sebagian besar fitur dengan benar. Hal
ini wajar karena terdapat banyak kemiripan warna pada kedua gambar tersebut, sehingga fungsi kita
tidak bisa memetakan nilai tersebut dengan tepat. Kita akan mencoba metode lain yang mungkin
dapat menghasilkan kemiripan yang lebih baik.

b. Brute-Force Matching dengan SIFT Descriptors dan Ratio Test

Kita masih menggunakan Brute-Force (BF) untuk metode kali ini. Yang membedakan
dengan metode sebelumnya adalah descriptor yang kita gunakan, yaitu SIFT (Scale-Invariant
Feature Transform). SIFT ini merupakan salah satu metode untuk membuat descriptor dimana kita
menentukan bentuk descriptor ini yang digambarkan dalam model histogram 3D. Gradien pada tiap
pixel digambarkan sebagai sebuah vektor yang terbentuk atas lokasi pixel dan arah gradien. Sebuah
pixel akan dimasukan kedalam histogram 3D dengan ukuran yang ditentukan, lalu tiap sample pixel
dalam histogram tersebut akan dilakukan pembobotan untuk membentuk descriptor. Pembobotan
Gaussian juga diberikan untuk mengurangi noise. Perhatikan ilustrasi dari apa yang dilakukan SIFT
descriptor berikut.

Dengan adanya pembobotan dan juga vektor tersebut, maka kita bisa menggunakan fungsi
tersebut untuk menentukan arah fitur dan kontur dari sebuah gambar. Perhatikan gambar berikut ini
sebagai ilustrasi.

97
 Kita tidak perlu menghitung secara matematis, karena pada OpenCV, kita memiliki fungsi
untuk SIFT ini. Kita akan menggunakan dua gambar yang sama yang kita gunakan sebelumnya,
yaitu kedua gambar siberian husky yang telah kita ubah menjadi grayscale. Perhatikan sintaksnya
berikut ini.

Mari kita cek kedua gambar train dan test kita.

Setelah ini, kita akan membuat SIFT detector kita. Penulisan sintaksnya mirip dengan yang
telah kita lakukan pada metode dengan ORB detector sebelumnya. Perhatikan penulisan sintaksnya
berikut ini.

98
 Kita pertama akan membuat object SIFT dulu dengan menggunakan kelas
cv2.SIFT_create(). Sama seperti pada metode sebelumnya, kita menggunakan
detectAndCompute() untuk membuat keypoint dan juga descriptor untuk tiap gambar. Kita juga
menggunakan fungsi cv2.bfMatcher() untuk membuat object BF. Hal yang berbeda adalah kita
akan memasangkan tiap descriptor pada kedua gambar dengan menggunakan metode KNN. Metode
ini mirip dengan KNN yang kita pelajari pada materi Supervised Learning pada Machine
Learning, dimana kita mencari nilai k yang terbaik untuk mendapatkan hasil yang optimal. Pada
kasus ini, kita akan mencari sejumlah k best match.
Hal lain yang berbeda adalah disini kita menggunakan teknik yang disebut dengan Ratio
Test. Tes rasio ini akan mencari dan menganggap nilai m merupakan sebuah fitur yang memiliki
jarak paling dekat antar kedua gambar. Kita membandingkan nilai jarak vektor m dengan n dan
apabila nilai m lebih kecil dari 75% jarak n, maka kita akan menganggap fitur tersebut memiliki
jarak yang kecil, yang berarti dekat antar gambar. Kita akan memasukan nilai tersebut ke dalam
array good. Terakhir, kita akan menggambarkan garis fitur tersebut dengan menggunakan fungsi
cv2.drawMatchesKnn(), yang memiliki parameter yang sama sebelumnya, namun perbedaan input
arraynya adalah hasil KNN.

99
 Perhatikan bentuk output yang dihasilkan dari sintaks tersebut.

Kita lihat bahwa pada output dengan menggunakan metode ini, masih banyak fitur yang
tidak akurat, walaupun metode ini masih lebih baik dibandingkan metode dengan ORB sebelumnya.
Kita akan mencoba metode ketiga, yaitu menggunakan FLANN untuk mendapatkan hasil akurasi
yang lebih tinggi.

c. FLANN-based Matcher
Metode ini merupakan metode yang berbeda dari metode BF sebelumnya. FLANN sendiri
merupakan kepanjangan dari Fast Library for Approximate Nearest Neighbors. Metode ini memiliki
beberapa algoritma yang dapat digunakan untuk data berukuran besar dan yang memiliki dimensi
tinggi. Uniknya, dengan menggunakan FLANN ini, walaupun data yang digunakan besar, tapi
metode ini jauh bekerja lebih cepat dibandingkan dengan menggunakan BFMatcher.
Salah satu perbedaan antar menggunakan FLANN dengan BFMatcher adalah FLANN ini
menggunakan KNN untuk mencari nilai descriptor yang terdekat. Karena hanya mencari yang
terdekat, maka descriptor yang dihasilkan belum tentu berupa best match, namun hanya good match
saja. Apabila kita memiliki jumlah data yang sama, ada kemungkinan kita mendapatkan hasil yang
lebih baik ketika kita menggunakan BFMatcher. Perbedaan yang sangat signifikan akan didapatkan
apabila kita menggunakan data dengan jumlah yang sangat besar apabila menggunakan FLANN.

100
 Ketika kita menggunakan FLANN-based Matcher, kita perlu menuliskan dua dictionaries
yang menentukan algoritma apa yang akan kita gunakan dan juga parameter yang dapat diterima.
Dictionary pertama merupakan index_params yang berisikan algoritma yang ingin kita gunakan
pada kelas FLANNBasedMatcher. Dictionary yang kedua merupakan search_params yang
berisikan parameter untuk bagaimana FLANN ini akan mencari descriptor dengan nilai terdekat
dengan menuliskan berapa banyak pohon dalam indeks harus dijalankan. Makin tinggi nilainya akan
memberikan nilai presisi yang lebih baik, namun membutuhkan waktu yang lebih lama.
Kita akan mencoba untuk membuat sintaks Python dengan menggunakan metode FLANN
ini. Pertama kita akan memanggil kedua gambar siberian husky kita terlebih dahulu.

Setelah mendapatkan gambar grayscale tersebut, kita akan membuat fungsi FLANN
Matcher ini. Perhatikan sintaks berikut ini.

101
 Kita tetap akan mencari keypoint dan descriptor dengan menggunakan SIFT detector. Kita
juga membuat dua dictionary yang dibutuhkan untuk memanggil kelas cv2.FlannBasedMatcher,
yaitu index_params dan search_params. Index_params ini akan berisikan algoritma yang akan
kita gunakan, yaitu FLANN_INDEX_KDTREE, yang menggunakan metode pohon untuk mencari
kedekatan antar descriptor, dengan jumlah pohon yang kita gunakan sebanyak 5. Search_params
ini akan berisikan jumlah pohon yang akan dilewati oleh FLANN. Setelah kedua dictionary ini
terbentuk, kita akan memanggil fungsi cv2.FlannBasedMatcher() dimana kita bisa memasukan
kedua dictionary tersebut menjadi parameter cv2.FlannBasedMatcher(index_params,
search_params). Kita juga mencari kemiripan antar descriptor dengan menggunakan knnMatch()
karena kita menggunakan SIFT descriptor.
Setelah ini, kita akan melanjutkan sintaks kita untuk membuat dan mencari nilai good
matches untuk memetakan mana descriptor yang memiliki kesamaan antar dua gambar. Perhatikan
sintaks berikut ini.

102
 Kita akan membuat sebuah variabel matchesMask yang berisikan array dengan nilai [0,0]
sejumlah ukuran dari matches. Dengan menggunakan tes rasio sama seperti yang kita lakukan pada
metode SIFT sebelumnya, kita akan mengecek descriptor mana yang memiliki jarak kurang dari
70% jarak pada matches kedua. Apabila ada, maka kita akan mengubah nilai pada array tersebut
dari [0,0] menjadi [1,0].
Kita juga akan membuat sebuah parameter baru bernama draw_params, yang nantinya
parameter ini akan kita masukan menjadi keyword arguments untuk fungsi
cv2.drawMatchesKnn(). Setelah menuliskan seluruh sintaks tersebut, apabila kita menjalankan
sintaks diatas, maka kita akan mendapatkan hasil berikut ini.

103
 Pada gambar tersebut, seluruh descriptor yang tergambar bukanlah descriptor yang
merupakan best match, namun hanya descriptor yang memiliki good match saja dan memenuhi
kriteria tes rasio yang kita tuliskan sebelumnya. Seluruh nilai good match yang ditemukan akan
digambarkan menjadi point titik berwarna merah. Dengan kita menghitung good match dan bukan
best match, maka kita dapat melihat ada beberapa titik merah yang dihubungkan secara tidak
relevan, karena dengan metode ini kita hanya mencari descriptor yang terdekat saja.

7. Watershed Algorithm
Algoritma yang akan kita bahas ini juga merupakan salah satu aplikasi dari object detection
yang menggabungkan beberapa metode sebelumnya yang telah kita pelajari dari metode object
detection. Dengan menggunakan Watershed Algorithm, kita bisa menganggap sebuah gambar
tersebut berfungsi seperti sebuah peta topografi, dimana kita bisa menggambarkan tingkat kecerahan
warna dari tiap titik berdasarkan ketinggian dan mencari garis yang digunakan sebagai pemisah.
Dengan menggunakan algoritma ini, kita bisa membentuk semacam gambar topografi yang banyak
digunakan untuk memetakan kedalaman sebuah wilayah di daratan.
Ide dari algoritma ini adalah menggunakan gambar grayscale untuk membentuk permukaan
topografi tersebut. Apabila kita mendapatkan nilai pixel dengan intensitas yang tinggi, maka kita
bisa menganggap bahwa bagian yang memiliki intensitas tinggi tersebut merupakan gambar sebuah
puncak, sedangkan sebaliknya apabila kita mendapatkan nilai pixel dengan intensitas yang rendah,
maka kita bisa menganggap bahwa bagian yang memiliki intensitas rendah tersebut merupakan
gambar sebuah lembah. Algoritma ini juga dapat memberikan warna kepada tiap lembah yang
dihasilkan dengan sebuah warna air buatan (label). Dengan terbentuknya lembah yang berisikan
“air” ini, maka berdasarkan kedalamannya, kita dapat melihat warna yang berbeda - beda pada air
ini dan dapat melihat ada beberapa warna berbeda yang akan melebur. Algoritma ini akan
membentuk sebuah batas pada gambar dimana “air” tersebut melebur, sehingga terlihat seperti kita
memiliki beberapa macam kedalaman “air”.

104
 Dengan teknik yang dimiliki algoritma ini, kita dapat dengan mudah membuat sebuah
segmentasi pada gambar. Salah satu aplikasinya adalah dengan memisahkan sebuah background dan
foreground dari sebuah gambar, dimana mungkin sulit untuk dilakukan dengan menggunakan
algoritma lainnya.
Karena kita akan memberikan label kepada tiap segmen pada gambar tersebut, maka kita
juga dapat memberikan segmen tersebut secara manual kepada algoritma. Contoh dari aplikasi ini
adalah ketika kita memberikan sebuah gambar pemandangan alam, dimana dengan menggunakan
algoritma ini, kita bisa memisahkan mana yang merupakan sebuah gunung, langit, dataran, pohon,
dan yang lainnya. Perhatikan contoh ilustrasinya pada gambar berikut ini.

Kita akan mencoba untuk membuat sintaksnya dengan menggunakan Python dan OpenCV.
Pertama kita akan memanggil gambar yang akan kita gunakan. Pada contoh kali ini, kita akan
menggunakan gambar yang berbeda, yaitu kita menggunakan gambar koin. Gambar koin ini cukup
sering digunakan untuk percobaan menggunakan algoritma ini, karena algoritma ini dapat
membentuk segmentasi dari gambar koin tersebut. Berikut ini gambar koin yang akan kita gunakan.

105
 Dengan menggunakan Python dan OpenCV, kita akan memanggil gambar koin ini dari link
yang sudah disediakan untuk dapat ditampilkan dalam Google Colab kita. Perhatikan penulisan
sintaksnya berikut ini.

Path file tersebut merupakan path file untuk menampilkan gambar koin tersebut. Ketika kita
membuka file tersebut dengan OpenCV, kita akan mendapatkan gambar koin tersebut dengan warna
BGR seperti berikut ini.

106
 Kita sebagai manusia bisa membedakan antara koin dan background pada gambar tersebut,
namun tidak demikian dengan komputer. Kita akan mencoba membuat segmentasi agar komputer
dapat membedakan mana yang merupakan background, dan mana yang merupakan sebuah koin.
Kita akan melakukan beberapa operasi seperti image smoothing, mengubah warna menjadi
grayscale, membuat threshold, lalu mencari kontur untuk dapat memproses gambar koin tersebut.
Perhatikan bahwa operasi - operasi tersebut telah kita pelajari pada bagian pembahasan sebelumnya.

Setelah ini, kita akan mengubah warna dari gambar tersebut menjadi grayscale, untuk dapat
mempermudah melakukan segmentasi.

107
 Kita juga akan memberikan sebuah threshold pada gambar tersebut agar menjadi sebuah
gambar biner.

Setelah ini kita akan coba untuk mendeteksi kontur yang dihasilkan dari gambar tersebut.

108
 Perhatikan saat kita menggambar kontur tersebut pada gambar koin asli kita. Kita lihat
bahwa dengan menggunakan cv2.findContours(), kita mendapatkan kontur pada koin bagian
terluar, namun untuk koin bagian terdalam, kita tidak mendapatkan kontur tersebut. Kita
mengharapkan agar kontur tersebut juga dapat ditemukan pada koin bagian terdalam supaya kita
bisa melakukan segmentasi dan memisahkan antara koin dan background. Dengan metode object
detection yang sudah kita pelajari sebelumnya, kita belum bisa memisahkan gambar koin dengan
backgroundnya tersebut.
Kita akan mencoba ulang dari awal dengan metode yang berbeda menggunakan algoritma
watershed. Kita akan mengambil ulang gambar kita.

109
 Sama seperti pada langkah sebelumnya, kita akan menerapkan image smoothing, untuk
membuat gambar koin tersebut sampai blur. Kita hanya menginginkan agar gambar tersebut
menghasilkan hanya lingkaran saja.

Kita juga akan mengubah gambar tersebut menjadi grayscale, sama seperti langkah
sebelumnya yang kita lakukan.

110
 Kali ini, kita akan mencoba untuk membuat threshold. Agar Watershed Algorithm ini dapat
bekerja, kita tidak boleh memiliki noise sama sekali pada gambar kita. Kita dapat menggunakan
mode cv2.THRESH_OTSU untuk benar - benar mengeliminasi noise pada saat kita melakukan
thresholding.

Kita sampai pada tahap threshold, yang merupakan tahap permasalahan yang sama yang kita
temukan seperti pada cara sebelumnya. Kita lihat pada gambar diatas, bahwa ada beberapa koin
yang terlihat menyatu. Sulit untuk memisahkan kontur antar koin sehingga kita mendapatkan
segmentasi antar koin tersebut.
Hal yang dapat kita lakukan adalah dengan melakukan distance transform. Metode ini akan
mengubah nilai pixel dari gambar tersebut dengan aturan demikian : Apabila sebuah pixel makin
jauh dengan angka 0, maka nilai pixel tersebut akan diperbesar. Dengan mengaplikasikan distance
transformation ini, maka kita akan merubah gambar kita sesuai dengan jaraknya pada gambar.
Untuk melakukan distance transformation ini, kita menggunakan fungsi cv2.distanceTransform()
dengan parameter yang bisa kita berikan adalah cv2.distanceTransform(gambar, tipe_distance,
mask_size). Nilai default yang bisa diberikan dalam distance_type adalah cv2.DIST_L2 dan untuk
mask_size adalah angka 0, 3, atau 5, yang memiliki efek kepada cv2.DIST_L2. Perhatikan contoh
penulisan sintaksnya berikut ini.

111
 Perhatikan bahwa sekarang kita melihat gambar tersebut agak samar, hal ini dikarenakan
distance transform yang kita gunakan menilai gambar tersebut jauh, sehingga membuat nilai pixel
tersebut sangatlah kecil, lalu di bagian tengah menjadi lebih terang karena sesuai dengan teori,
bahwa semakin jauh dengan pixel 0, maka nilainya akan lebih terang. Dengan menggunakan
distance transform ini juga, kita mengubah semua lingkaran koin yang tadinya menempel satu sama
lain, sehingga bisa terpisah. Setelah ini, kita akan memberikan sebuah threshold lagi agar lingkaran
tersebut dapat terlihat lebih jelas. Kita akan menggunakan fungsi threshold kita cv2.threshold()
untuk memberikan sebuah threshold agar kita bisa melihat gambar tersebut lebih jelas. Perhatikan
sintaks berikut ini.

Kita akan menuliskan nilai minimum threshold tersebut adalah 0,7 dari nilai maksimumnya.
Hal ini menyebabkan seluruh nilai yang lebih rendah dari nilai minimum tersebut akan menjadi nilai
0,7 dari nilai maksimum. Perhatikan hasilnya berikut ini.

112
 Kita sekarang cukup yakin bahwa keseluruhan titik tersebut merupakan sebuah segmentasi
koin dibandingkan dengan gambar sebelumnya yang koinnya saling terhubung satu sama lain. Kita
lihat pada gambar diatas. Kita memiliki titik yang jelas untuk melakukan segmentasi, namun
perhatikan bahwa titik tersebut bukanlah titik pada koin, namun hanya merupakan titik bantuan
yang kita gunakan untuk lakukan segmentasi. Apabila kita membandingkan dengan gambar koin
awal kita, gambar tersebut memiliki lingkaran yang lebih besar. Oleh karena itu, kita dapat gunakan
cv2.subtract() yang digunakan untuk mengurangi nilai pixel antar gambar. Hal ini digunakan untuk
menandakan bahwa gambar - gambar koin sebelumnya memiliki segmentasi sesuai dengan hasil
segmentasi yang kita hasilkan pada gambar variabel foreground tersebut. Perhatikan sintaks
berikut.

Kita pertama merubah nilai pixel dari foreground menjadi sebuah integer dahulu, lalu kita
akan menggunakan fungsi cv2.subtract() untuk menyelisihkan nilai pixel pada image_thresh dan
foreground. Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan hasil berikut ini.

113
 Dari hasil selisih kedua gambar tersebut, perhatikan bahwa sekarang kita terkesan
menciptakan sebuah “label” pada gambar tersebut, yang ditandai dengan titik hitam kecil. Dengan
menggunakan metode ini, kita seakan memberi tahu algoritma bahwa kita menginginkan seluruh
bagian gambar yang ditandai titik hitam tersebut merupakan sebuah foreground dan digolongkan
menjadi sebuah segmen sendiri.
Sekarang kita akan membuat sebuah markers yang digunakan untuk memberi label untuk
Watershed Algorithm. Kita akan menggunakan fungsi cv2.connectedComponents() untuk
menandakan markers pada sebuah gambar. Parameter yang bisa kita berikan adalah
cv2.connectedComponents(gambar). Gambar ini yang akan kita jadikan patokan untuk membuat
gradasi nantinya pada Watershed Algorithm. Perhatikan penulisan sintaksnya berikut ini.

114
 Dengan menggunakan cv2.connectedComponents(), kita akan menghasilkan sebuah
markers yang memiliki matriks seluruhnya bernilai 0. Kita akan menambah nilai tersebut dengan 1
agar tidak menjadi benar - benar hitam seluruhnya. Lalu kita juga akan memaksa seluruh nilai
markers dimana posisinya sama dengan gambar variabel subtraction kita yang memiliki pixel =
255 menjadi 0. Sehingga, apabila kita jalankan sintaks tersebut, kita akan mendapatkan hasil
markers berikut ini.

Setelah kita mendapatkan gradasi dari markers tersebut, kita akan memasangkan markers
tersebut dengan gambar asli kita. Kita menggunakan fungsi cv2.watershed() untuk dapat
memberikan gradasi pada gambar asli kita. Parameter yang bisa dimasukan adalah
cv2.watershed(gambar_asli, markers). Perhatikan penulisan sintaksnya berikut ini.

115
 Ketika kita mencoba menampilkan markers, sekarang akan berubah menjadi seperti ini.

Kita lihat sekarang bahwa kita sudah mendapatkan gradasi warna dari koin tersebut.
Sekarang kita akan menggambarkan kontur tersebut dengan metode Contour Detection yang telah
kita pelajari sebelumnya. Perhatikan sintaksnya berikut ini.

Dari sintaks diatas, kita akan membuat sebuah kontur yang diambil dari markers tersebut.
Kontur yang terdeteksi akan kita gambarkan kepada image_bgr, yaitu gambar koin asli kita yang
kita baca sebelumnya dari Google Drive. Ketika kita jalankan sintaks tersebut, kita akan
mendapatkan pembagian kontur pada masing - masing koin. Perhatikan gambar berikut ini.

116
 Perhatikan bahwa sekarang dengan menggunakan Watershed Algorithm, kita sudah
berhasil melakukan segmentasi dengan membedakan koin dengan background dengan baik.
Walaupun kita melihat masih ada bagian koin yang tidak terdeteksi berbentuk bulat, namun hasilnya
jauh lebih baik dari percobaan pertama kita.

8. Face Detection
Bagian Face Detection ini merupakan bagian terakhir yang akan kita bahas dalam
pembahasan mengenai object detection ini. Face Detection merupakan salah satu bagian dari object
detection, dimana algoritma yang kita buat dapat mendeteksi apakah ada wajah manusia didalam
gambar tersebut, dan mencari tahu posisinya pada gambar tersebut. Perhatikan bahwa metode Face
Detection ini berbeda dengan Face Recognition, karena pada metode ini kita hanya mencari tahu
apakah ada wajah di dalamnya. Algoritma yang kita buat tidak dapat mengetahui pemilik wajah
tersebut, ataupun tidak bisa mengenali siapa yang ada didalam gambar tersebut, karena kita hanya
mendeteksi apakah terdapat wajah atau tidak saja, dan bukan untuk mengenali wajah tersebut.
Untuk membuat sebuah algoritma Face Recognition, dibutuhkan data yang jauh lebih banyak dan
juga model Deep Learning.
Pada pembahasan mengenai Face Detection ini, kita akan berfokus menggunakan Haar
Cascades, yang merupakan komponen penting dari framework object detection menggunakan
Viola-Jones object detection.

117
 Face Detection menjadi sebuah metode object detection yang populer, karena
kemampuannya untuk mendeteksi wajah manusia dalam gambar tersebut, dan juga mencari dimana
lokasinya dalam gambar. Metode ini menjadi sebuah dasar dan banyak digunakan dalam berbagai
macam aplikasi, seperti biometric sign-in yang mungkin sekarang cukup populer digunakan untuk
masuk ke dalam sebuah aplikasi yang membutuhkan keamanan lebih tinggi.
Metode Viola-Jones merupakan metode yang ditemukan oleh Paul Viola dan Michael
Jones pada tahun 2001, dengan mempublikasikan sebuah metode dimana bisa melakukan deteksi
wajah dengan konsep yang sederhana dan memiliki beberapa key features yang sedikit. Mereka juga
memberikan sebuah ide untuk melakukan pre-komputasi pada beberapa gambar dahulu untuk
menghemat waktu ketika kita melakukan pemrosesan nantinya.
Konsep dari face detection yang diajukan oleh Viola-Jones adalah dengan mencari sebuah
fitur inti dalam sebuah gambar, apabila fitur inti ini ditemukan dalam gambar, maka kita dapat
menyimpulkan bahwa dalam gambar tersebut terdapat sebuah gambar wajah. Berikut ini merupakan
beberapa fitur inti yang diajukan oleh Viola-Jones.

Cara untuk menghitung apakah fitur tersebut penting dan terdapat pada gambar adalah
dengan cara kita mencari selisih dari nilai rata - rata yang ada pada fitur tersebut. Perhatikan ilustrasi
berikut untuk memahami konsep tersebut.

118
 0 0.1 0.8 1

0.3 0.1 0.7 0.8

0.1 0.2 0.8 0.8

0.2 0.2 0.8 0.8

Misalkan apabila kita mengecek dengan menggunakan edge features, kita mendapatkan nilai
pixel dengan nilai ilustrasi diatas. Sebuah fitur yang sempurna adalah fitur yang bernilai 1. Makin
mendekati angka 1, maka fitur tersebut akan semakin penting untuk penentuan apakah ada wajah
atau tidak pada gambar tersebut. Untuk menghitung seberapa penting fitur tersebut, kita akan
mengambil nilai rata - rata dari fitur yang gelap dikurangi rata - rata dari fitur yang terang. Total
nilai dari fitur gelap (0,8 x 6 + 1 + 0,7 = 6,5) dan total nilai dari fitur terang (0,1 x3 + 0,2 x3 + 0,3 +
0 = 1,2), sehingga kita bisa mendapatkan nilai rata - rata dari fitur gelap (6,5 / 8 = 0,8125) dan rata -
rata dari fitur terang (1,2/8 = 0,15). Sehingga kita mendapatkan nilai selisihnya adalah 0,6625. Kita
bisa memberikan sebuah threshold misalkan 0,5, sehingga seluruh fitur yang memiliki nilai lebih
dari 0,5 akan kita anggap sebagai fitur yang penting, sehingga dapat kita simpulkan bahwa pada area
gambar tersebut, akan terdapat fitur yang kita inginkan.
Perhatikan dengan menggunakan metode komputasi berikut ini, kita bisa mencari tahu
bagian gambar mana yang memiliki fitur yang kita inginkan sebagai penentuan apakah ada gambar
wajah atau tidak dalam gambar tersebut. Namun dengan menggunakan metode tersebut, kita akan
membutuhkan memori Python yang sangat besar karena apabila data gambar yang dimiliki besar,
akan sangat memakan banyak resources dan juga biaya untuk komputasi. Algoritma yang diberikan
oleh Viola-Jones adalah dengan menggunakan integral image untuk menyelesaikan permasalahan
komputasi ini. Dengan menggunakan algoritma ini, kita akan menjumlahkan nilai pixel dari
algoritma secara horizontal dan juga vertikal. Perhatikan ilustrasinya berikut ini.

119
 Integral image bekerja dengan cara menjumlahkan nilai pixel berdasarkan area. Perhatikan
ilustrasi dari gambar diatas. Kita akan memulai dari nilai pixel pada pojok kiri teratas, yaitu 1.
Apabila kita lihat pixel sebelahnya bernilai 3. Maka pada gambar integral image, lokasi pixel
sebelah kanannya akan menjadi 4, yang menandakan pixel 1 + 3. Apabila kita lanjut ke sebelah
kanannya yaitu pixel 7, sehingga pada integral image, kita mendapatkan angka 11, dan begitu
seterusnya.
Kita juga melakukan cara yang sama secara vertikal. Ketika kita mulai dari pixel 1 dan kita
lihat 1 kotak kebawah, kita melihat ada angka 12, sehingga ketika kita jumlahkan, maka pada
integral image pada kotak dibawah kotak 1, akan mendapati hasil pixel 13. Metode tersebut akan
dilakukan seterusnya sampai kita mendapatkan total dari seluruh pixel pada seluruh gambar. Untuk
mencari tahu nilai lokasi dari sebuah pixel dengan menggunakan persegi, kita bisa menggunakan
cara berikut ini.

Apabila kita ingin mengetahui nilai dari sebuah pixel pada lokasi tertentu didalam integral
image tersebut, sebagai contoh seperti gambar berikut ini.

120
 Kita bisa melakukannya dengan menghitung jumlah nilai kotak yang ada tersebut. Untuk
dapat mencari nilai gabungan dari kedua kotak diatas, yaitu :

Kita bisa memanfaatkan integral image, dengan cara mengambil nilai dari pojok kanan
bawah dari tiap kotak, karena nilai pojok kanan bawah pasti memiliki angka terbesar. Kita akan
menyelisihkan kedua nilai tersebut untuk mendapatkan nilai pixel pada kotak yang kita inginkan.

Perhatikan bahwa kita menggabungkan kedua persegi pada gambar asli yang berwarna biru,
sehingga persegi besar kita sekarang berukuran 4x3. Kita juga akan melihat pada integral image kita
dengan ukuran 4x3, lalu kita akan jumlah diagonal dari kiri atas dan kanan bawah yang akan di-
selisihkan dengan diagonal kanan atas dan kiri bawah, sehingga kita mendapatkan nilai sub-persegi
yang sama, yaitu 17, sama seperti hasil yang kita hitung sendiri sebelumnya.

121
 Dengan menggunakan metode ini, kita menghemat waktu dan biaya komputasi daripada kita
melakukan perhitungan satu persatu terhadap sebuah fitur. Ketika kita melakukan penghitungan
pixel tersebut, dan menentukan bahwa gambar tersebut gagal untuk memenuhi kondisi yang
diberikan, maka kita bisa menganggap bahwa gambar tersebut tidak memiliki fitur yang diinginkan,
yang pada kasus ini adalah sebuah wajah manusia, sehingga kita bisa berhenti untuk melanjutkan
pencarian pada gambar tersebut.
Umumnya, banyak orang yang akan berpikir bahwa kita akan mengecek seluruh pixel pada
gambar untuk mencari apakah gambar tersebut memiliki fitur yang kita inginkan atau tidak. Namun
pada praktiknya, kita tidak melakukan hal ini karena hal ini sangat boros waktu dan juga biaya
komputasi yang digunakan. Yang akan kita lakukan adalah kita memberikan sebuah classifier atau
kondisi pengecekan yang kita ingin lakukan, untuk mengecek apakah ada sebuah wajah dalam
gambar tersebut.

Hal yang pertama kita lakukan adalah kita membutuhkan gambar dengan muka menghadap
pada kamera. Apabila gambar yang kita miliki adalah gambar berwarna, kita akan mengubah
gambar tersebut menjadi grayscale, karena disini kita hanya ingin menggunakan rentang pixel hitam
dan putih saja 0 - 255. Setelah ini, kita akan memberikan fitur yang dinamakan Haar Cascade
Features, merupakan bentuk edge features putih dan hitam yang kita bahas sebelumnya. Perhatikan
gambar diatas. Kita akan mencoba untuk mengecek beberapa lokasi yang umum. Pada umumnya,
lokasi pertama yang akan kita cek adalah bagian mata dan pipi, karena umumnya warna mata akan
lebih gelap dibandingkan warna pipi yang paling dekat dengan mata. Apabila kondisi ini terpenuhi,
maka kita dapat asumsikan bahwa terdapat gambar wajah pada gambar tersebut.

122
 Apabila kita gagal untuk memenuhi fitur yang pertama yaitu mengecek mata dan pipi, kita
bisa mencoba untuk mengecek fitur lain yang penting. Biasanya fitur kedua yang kita cek adalah
bagian hidung dan mata atau pipi, seperti yang terlihat pada gambar sebelumnya. Kita akan
melakukan hal ini berulang - ulang sampai algoritma kita dapat mendeteksi bahwa classifier yang
kita berikan mendeteksi sebuah fitur yang cocok dengan kriteria kita, yang menandakan bahwa
algoritma tersebut berhasil mendeteksi sebuah wajah.
Kelemahan dari algoritma yang kita gunakan ini adalah kita membutuhkan dataset yang
sangat besar apabila kita ingin membuat fitur kita sendiri. Namun, OpenCV telah memiliki banyak
sekali beberapa fitur yang sudah dilakukan pelatihan sebelumnya. OpenCV sendiri memiliki
beberapa fitur file XML yang telah dilakukan pelatihan sebelumnya dengan menggunakan fitur
Haar Cascades. Walaupun beberapa fitur telah disediakan untuk kita dapat mendeteksi sebuah
wajah, kita dapat membuat fitur sendiri untuk mendeteksi wajah, misalkan kita ingin mendeteksi
bentuk wajah hewan, yang mungkin belum disediakan pada fitur Haar Cascades. Kita akan lebih
banyak mempelajari ini ketika kita mulai menggunakan Deep Learning untuk memproses gambar
kita nantinya.
Kita akan mencoba untuk menggunakan Python untuk melakukan face detection. Gambar
yang akan kita gunakan ada 2, yaitu foto Pak Presiden Joko Widodo yang diambil dari situs resmi
yang sudah kita simpan dalam Google Drive sebelumnya, dan yang satu lagi merupakan gambar
konferensi kepresidenan yang diambil juga dari website yang telah kita simpan juga dalam Google
Drive. Kita akan menggunakan Python untuk membaca kedua file ini sekaligus. Selain itu, kita juga
akan membaca modul Haar Cascades yang telah dilatih sebelumnya, yang disimpan dalam file
XML. Kita juga akan membaca modul ini. Kumpulan modul XML lainnya dari Haar Cascades
yang sudah dilatih juga dapat dilihat dalam file ini, dan dapat diakses menggunakan Python untuk
melakukan pelatihan komponen face detection. Perhatikan sintaks Python berikut ini.

123
 Ketika kita menjalankan sintaks Python diatas, kita dapat melihat kedua gambar yang akan
kita gunakan, perhatikan hasil keluarannya berikut ini.

124
 Kedua gambar tersebut masih dalam warna BGR. Perhatikan gambar tersebut. Pada gambar
foto Joko Widodo, kita hanya melihat hanya ada 1 orang dalam foto tersebut, dengan wajah
menghadap ke kamera. Foto tersebut juga bersih dari noise, dan dapat kita gunakan secara langsung
untuk diproses. Kita juga memiliki 1 foto lainnya, yaitu foto konferensi, dimana foto tersebut
memiliki jumlah orang lebih dari 1, dengan wajah yang bervariasi dan arah muka yang menghadap
ke berbagai macam arah. Kita akan mencoba untuk membuat sebuah fungsi dimana kita bisa
mendeteksi wajah pada kedua gambar ini.
Sebelum itu, kita akan mengubah warna pada kedua gambar tersebut menjadi grayscale
seperti yang telah kita tuliskan pada bagian teori. Setelah itu, kita juga akan mengambil model yang
sudah dilatih dari folder HaarCascade. Kita bisa mengambil path dari modul tersebut dari link yang
disediakan sebelumnya. Model yang akan kita gunakan merupakan model face detection
‘haarcascade_frontalface_default.xml’. Perhatikan contoh penulisan sintaksnya berikut ini.

Setelah ini, kita akan membuat sebuah fungsi untuk mendeteksi wajah dalam gambar. Dalam
fungsi tersebut, kita akan memasukkan duplikat gambar tersebut kedalam model yang telah dilatih.
Kita memanggil model tersebut dengan menggunakan fungsi detectMultiScale(). Fungsi ini akan
menghasilkan sebuah tuple yang berisi 4 persegi, yang menggambarkan lokasi komponen yang
terdeteksi. Dari informasi ini, kita dapat memvisualisasikan keluarannya menjadi sebuah persegi,
yang dapat kita gambar. Perhatikan sintaksnya berikut ini.

125
 Selanjutnya, kita akan menggunakan fungsi tersebut untuk menampilkan gambar hasil
deteksi wajah kita. Perhatikan sintaks berikut ini.

Ketika kita menjalankan sintaks tersebut, kita akan mendapatkan keluaran berupa gambar
yang telah diberikan persegi. Perhatikan gambar dari Joko Widodo dan juga gambar konferensi yang
dihasilkan.

126
 Kita perhatikan, dari gambar Joko Widodo, kita mendapatkan hasil deteksi wajah yang
sempurna. Kita lihat bahwa model tersebut dapat mendeteksi wajah Pak Joko Widodo dengan baik
dan menemukan lokasinya dengan tepat juga. Namun perhatikan pada gambar konferensi. Pada
gambar tersebut, banyak wajah yang terdeteksi oleh fungsi kita, namun ada juga beberapa wajah
yang sulit untuk terdeteksi. Beberapa wajah yang menghadap ke samping juga sulit untuk dideteksi.
Untuk itu, kita akan coba melakukan pengaturan terhadap fungsi kita, agar mencoba mendapatkan
hasil yang lebih baik. Perhatikan sintaks berikut.

Kita membuat fungsi baru bernama adj_face_detection. Perbedaannya kali ini adalah kita
akan memasukkan parameter dalam fungsi detectMultiScale, yaitu scaleFactor dan
minNeighbors. Parameter scaleFactor ini akan menentukan ukuran gambar tersebut. Dengan
menuliskan 1,14 maka kita memperbesar gambar tersebut sebesar 1,14 kali. Angka ini bisa
bervariasi tergantung kebutuhan, namun setelah beberapa kali uji coba saat pembuatan modul ini,
nilai 1,14 memiliki performa yang paling baik untuk mendeteksi gambar konferensi tersebut. Kita
juga menuliskan parameter minNeighbors ini yaitu 2, yang memiliki arti seberapa banyak wajah
yang dapat terdeteksi dalam sebuah persegi. Dengan menuliskan nilainya 2, maka wajah yang
terlalu dekat dengan wajah seseorang dapat dideteksi dalam 1 kotak yang sama. Apabila kita
membuat hal ini terlalu kecil seperti 1, terkadang fungsi tersebut dapat mendeteksi hal lain yang
bukan merupakan wajah menjadi masuk ke dalam sebuah persegi.

127
 Perhatikan hasil keluaran dari sintaks tersebut.

Dengan mengatur ulang parameter tersebut, kita bisa mencoba mencari hasil yang lebih
akurat. Kita juga bisa mencoba beberapa model lainnya apabila model ini dirasa kurang efektif
untuk mendeteksi jumlah orang yang banyak.
Setelah ini, kita akan mencoba untuk menggunakan satu model lainnya, yaitu model yang
digunakan untuk mendeteksi mata, atau eye detection. Sintaks yang kita gunakan sama, namun kita
akan mengubah beberapa parameter dan juga mengubah model yang digunakan. Perhatikan sintaks
berikut ini.

128
 Dengan menggunakan fungsi eye_detection yang kita buat, kita akan coba untuk mendeteksi
mata dalam gambar Pak Joko Widodo dan juga gambar konferensi tersebut. Kita dapat menuliskan
sintaks tersebut seperti berikut ini.

Perhatikan hasil keluaran dari sintaks tersebut.

129
 Pada gambar Pak Joko Widodo, kita mendapatkan hasil deteksi mata yang sempurna, dengan
model yang kita buat dapat mendeteksi dengan tepat lokasi dan ukuran dari mata tersebut. Namun
pada gambar konferensi, kita melihat bahwa model kesulitan untuk mendeteksi mata dari orang -
orang yang ada pada gambar tersebut. Apabila kita perhatikan dengan jelas, hal yang dideteksi
sebagai mata oleh model adalah posisi gambar berikut ini.

Kita dapat mengambil kesimpulan bahwa model eye detection yang kita miliki tidak dapat
digunakan untuk mendeteksi mata pada gambar konferensi. Pada gambar tersebut, yang terdeteksi
adalah bentuk lain dan bukan mata. Kita mungkin dapat mendeteksi mata apabila kita mencoba
menggunakan model lain.

Dengan demikian, kita telah mempelajari 8 teknik yang dapat digunakan untuk object
detection, dari template matching sampai dengan face detection. Kita bisa mengkombinasikan
beberapa metode tersebut, seperti yang kita gunakan pada Watershed Algorithm dan Feature
Matching untuk dapat mendeteksi benda dari bentuknya, ataupun deteksi wajah. Setelah ini kita
akan mempelajari penggunaan metode Deep Learning untuk membantu kita mengolah data visual
dengan akurasi yang lebih tinggi dan performa yang lebih baik lagi.

130
Computer Vision dengan
Deep Learning
Untuk mengolah data visual, kita sering mendengar banyak orang yang menggunakan
metode Deep Learning ini. Setelah kita pelajari pada modul Machine Learning, kita mengetahui
bahwa metode Machine Learning baik digunakan dengan jumlah data yang banyak. Namun,
apabila kita mengolah data berupa gambar, data yang kita miliki jauh lebih banyak dibandingkan
dengan data pada Supervised Learning ataupun Unsupervised Learning. Oleh karena itu, untuk
pengolahan data yang banyak seperti pada pengolahan gambar, kita banyak menggunakan metode
Deep Learning, dan terbukti sangat efektif.
Pada modul Deep Learning, kita juga telah mempelajari beberapa dasar dari Deep
Learning itu sendiri, dan juga beberapa metode didalamnya seperti penggunaan Basic Artificial
Neural Network (ANN) untuk mengolah data menggunakan deep neural network, Recurrent
Neural Network (RNN) untuk mengolah data yang memiliki urutan sekuensial ataupun untuk
melakukan forecast, dan juga Autoencoder yang digunakan untuk melakukan kompresi terhadap
data pada dimensi yang besar, lalu dapat menghasilkan dimensi yang lebih kecil ataupun sama.
Pada materi kali ini, kita akan menggunakan Deep Learning untuk mengolah data gambar.
Dua metode yang sebelumnya belum dipelajari pada materi Deep Learning, yaitu Convolutional
Neural Network (CNN) dan juga Generative Adversarial Network (GAN) merupakan dua metode
Deep Learning yang biasa digunakan untuk melakukan pengolahan terhadap gambar. Kita akan
mencoba untuk mempelajari kedua metode tersebut.

1. Convolutional Neural Network (CNN)

Convolutional Neural Network (CNN) merupakan salah satu metode Deep Learning yang
dapat dikatakan paling efektif digunakan pada data visual. Ingat sebelumnya pada saat melakukan
pembahasan pada materi Image Blurring dan Image Smoothing bahwa untuk memperbaiki
gambar, kita bisa melakukan konvolusi, yaitu dengan mengaplikasikan sebuah kernel yang berupa
filter pada gambar sesuai dengan ukuran kernel yang diberikan.

131
 Tujuan kita memberikan sebuah kernel adalah dengan memberikan pembobotan baru
terhadap pixel pada gambar tersebut, agar nilainya dapat berubah sesuai dengan kernel blur yang
kita berikan.

Dengan menggunakan CNN, kita dapat mengatur nilai pembobotan tersebut. Ketika kita
mempelajari metode ANN sebelumnya, metode ini juga dapat digunakan untuk data berupa gambar,
namun apabila kita menggunakan ANN, kita hanya mendapat akurasi yang baik, bukan yang
terbaik. Beberapa perbandingan kelebihan dan kekurangan yang telah diketahui secara umum untuk
kedua metode ini antara lain :

Kelebihan

Artificial Neural Network (ANN) Convolutional Neural Network (CNN)

ANN lebih fleksibel, dapat digunakan luas dan CNN digunakan untuk mengeksploitasi pola
bukan hanya untuk data berupa gambar visual dalam gambar, mengubahnya menjadi
fitur yang dapat dianalisa, walaupun pola
tersebut sangatlah kompleks

ANN bagus apabila digunakan pada data yang CNN bisa dilatih dengan menggunakan model
belum pernah diketahui sebelumnya apabila yang telah dilatih sebelumnya. Hal ini disebut
dilatih dengan benar dengan transfer learning, membuat waktu
pelatihan dapat berkurang karena sudah
melakukan proses pelatihan sebelumnya

ANN dapat digunakan untuk data yang CNN dapat menemukan sebuah pola dalam
kompleks, termasuk dengan data berupa gambar dimanapun posisi pola tersebut
gambar berada. Namun ketika gambar berubah - ubah
karena rotasi ataupun translasi, maka CNN
dapat mengalami kesulitan dalam
mengekstrak fitur pada gambar

132
 Kekurangan

Artificial Neural Network (ANN) Convolutional Neural Network (CNN)

Jumlah parameter yang dibutuhkan untuk CNN hanya dapat digunakan pada gambar
melatih model ANN pada data gambar sangat yang telah diketahui ukurannya. Ketika rasio
besar, untuk gambar berukuran 28x28 gambar berubah, diperlukan proses lain untuk
membutuhkan sekitar 100.000 parameter. dapat menyesuaikan.

ANN tidak mempedulikan adanya relasi antar CNN sulit untuk menemukan relasi terhadap
pixel dalam gambar, sehingga terkadang pola yang terlalu rumit. Mungkin CNN dapat
performansinya jauh lebih terbatas menemukan fitur dalam sebuah gambar
dibandingkan dengan menggunakan CNN. dengan baik, namun apabila gambar berubah
menjadi lebih general, terkadang CNN sulit
untuk menginterpretasikan fitur yang sama
pada gambar yang lebih general.

Kita lihat bahwa dengan menggunakan ANN dan CNN masing - masing memiliki kelebihan
dan kekurangannya masing - masing. Namun CNN tetap dipercaya memiliki performa yang jauh
lebih baik dibandingkan dengan ANN, dibalik semua limitasi yang dimiliki.

Konsep Model - Convolutional Layer

Kita menggunakan CNN untuk membuat sebuah convolutional layer yang digunakan untuk
mengatasi permasalahan yang terdapat pada ANN. Kita menggunakan convolutional layer ini untuk
memberikan beberapa lapis filter pada gambar input. Layer ini yang akan dilatih agar dapat
memberikan nilai weight yang baik pada filter tersebut. Dengan menggunakan CNN, kita juga
mengurangi jumlah parameter yang akan digunakan dengan memfokuskan data pada fitur lokal
yang diinginkan saja. Sehingga tidak semua neuron akan digunakan pada metode ini. Kita hanya
akan menggunakan neuron yang terhubung pada neuron lokal pada layer berikutnya, dimana biasa
layer ini merupakan layer filter pada layer selanjutnya. Kita akan mencoba untuk memahami apa
yang dimaksud dengan fitur lokal berikut ini.

133
 Model diatas merupakan model dari ANN yang telah kita pelajari sebelumnya pada materi
mengenai Deep Learning. Pada ANN, kita mengetahui bahwa seluruh input akan terhubung pada
layer pertama pada neural network, dimana layer ini akan mengekstrak informasi lebih dari input
yang tersembunyi. Dengan menggunakan model ANN ini, dengan seluruh input terhubung ke semua
neuron, maka parameter yang dihasilkan akan semakin banyak. Untuk mengatasi hal ini apabila kita
menggunakan data berupa gambar, kita menggunakan CNN. Pada CNN, bentuk dari hubungan input
dengan layer diilustrasikan pada gambar berikut ini.

134
 Pada CNN, yang merupakan convolutional layer, neuron hanya berfokus kepada fitur lokal,
sehingga neuron hanya terhubung pada neuron lokal saja dan tidak pada semua neuron yang berada
pada layer. Dengan konsep tersebut, kita seakan menciptakan sebuah filter. Model neural network
ini lalu akan memperkirakan pembobotan yang sesuai untuk filter ini. Kita sudah mengenal
beberapa jenis filter seperti blur, edge, dan lainnya. Filter tersebut telah kita ketahui nilai kernel
yang dimilikinya. Namun untuk beberapa kasus tertentu, seperti ketika kita melakukan face
detection, terkadang kita sulit menemukan filter yang tepat yang sudah ditentukan sebelumnya. Oleh
karena itu, dengan menggunakan CNN kita dapat membuat filter sendiri untuk beberapa kasus
tertentu. Jumlah filter yang diberikan ini bervariasi, dan bisa lebih dari 1. Untuk ilustrasi mengenai
filter yang berjumlah lebih dari 1, dapat kita lihat berikut ini.

Jenis neural network pada ilustrasi diatas merupakan ilustrasi dari input berbentuk 1D. Ingat
bahwa data gambar grayscale kita merupakan data berbentuk 2D (dengan input hanya hitam dan
putih). Dengan menggunakan gambar berbentuk 2D, mari kita perhatikan ilustrasi berikut, mengenai
bagaimana cara kerja dari CNN ini.

135
 Tiap pixel pada gambar akan dimasukan ke dalam tiap filter, dimana pixel ini akan
digolongkan menjadi fitur lokal. Ukuran filter tersebut dapat diatur dalam sebuah parameter
nantinya. Kita juga dapat mengaplikasikan lebih dari 1 filter terhadap beberapa pixel. Pada
kenyataannya, sebuah proses pengaplikasian Deep Learning pada data gambar biasanya memiliki
banyak sekali filter dan umumnya lebih dari 1. Kumpulan dari filter ini yang biasa disebut sebagai
convolutional layer.
Ilustrasi diatas merupakan contoh gambar dengan warna grayscale. Apabila kita memiliki
gambar yang berwarna RGB, maka kita akan memiliki tensor 3D. Dimensi ini adalah width, height,
dan color channel. Ketika kita membaca shape dari gambar tersebut dengan menggunakan fungsi
shape() pada Python, kita biasanya mendapatkan 3 komponen (h, w, c). Komponen ini menandakan
(height, width, color channel) dari gambar tersebut. Perhatikan bahwa angka color channel
menunjukkan jumlah channel warna yang ada pada channel tersebut. Apabila kita memiliki warna
RGB, color channel tersebut akan bernilai 3. Perhatikan gambar berikut ini.

136
 Gambar burung tersebut yang memiliki warna RGB merupakan gabungan dari warna dari
ketiga komponennya yaitu R, G, dan B. Karena memiliki ketiga warna ini, maka apabila kita cek
color channelnya, nilainya akan sama dengan 3.
Sehingga dapat kita simpulkan, bahwa ukuran 3D dari gambar RGB ini berbentuk seperti
gambar berikut ini.

Komputer tidak akan mengetahui warna apa yang terdapat pada tiap channel tersebut, namun
yang diketahui hanyalah gambar tersebut memiliki 3 channel warna. Untuk dapat memproses
gambar berwarna ini, kita akan menggunakan 3D Filter, dengan sebuah nilai untuk tiap color
channel.

137
Pooling Layers
Pada CNN, kita telah mengetahui bahwa tujuan kita adalah membuat sebuah convolutional
layer. Convolutional Layer ini terdiri dari beberapa filter yang dapat kita terapkan pada gambar
untuk mencari sebuah pola. Namun dengan banyaknya jumlah filter pada convolutional layer,
apabila kita memiliki 10 - 100 filter, maka ada kemungkinan jumlah parameter yang dihasilkan juga
akan semakin banyak. Untuk mengurangi terjadinya hal ini, kita menggunakan Pooling Layer.
Pooling layer digunakan dengan mengambil beberapa sampel pixel lalu kita akan memilih
beberapa pixel tersebut untuk menjadi representasi dari nilai filter kita yang memiliki nilai lebih
kecil. Untuk mendapatkan gambaran lebih jelasnya, perhatikan ilustrasi berikut.

1 3 6 8

4 2 9 7 4 9

8 7 3 2 9 3

7 9 1 1

Pada ilustrasi diatas, kita memiliki model yang disebut dengan Max Pooling. Pada Max
Pooling, kita akan melihat pixel dengan kotak berukuran 2x2 (nilai ini dapat ditentukan sebagai
sebuah parameter nantinya). Dari kotak ini, akan ada 4 pixel yang berada didalamnya, lalu dengan
menggunakan Max Pooling kita akan mengambil nilai maksimumnya dan membuat sebuah filter
baru dengan menggunakan nilai maksimum tersebut. Perhatikan kita memiliki sebuah filter
berukuran 4x4 dan sekarang tereduksi menjadi 2x2. Dengan menggunakan konsep pooling berikut,
maka kita memiliki potensi untuk kehilangan 75% informasi dari input, namun dengan memilih
nilai pixel maksimum yang diharapkan dapat mewakili informasi dari tiap kotak, maka kita

138
masih mendapatkan gambaran besar dari fitur yang berada pada lokasi pixel tersebut.
Selain menggunakan konsep Max Pooling, kita juga memiliki jenis pooling lainnya,
yaitu Average Pooling. Dengan model Average Pooling ini, kita mencari nilai rata - rata pixel dari
tiap kotak.

1 3 6 8

2. 7.
4 2 9 7 5 5

7. 1.
8 7 3 2 75 75

7 9 1 1

Sebagai kesimpulan, dengan menggunakan metode pooling ini, kita bisa mengurangi jumlah
parameter yang dibutuhkan dalam model. Hal ini dapat berdampak positif pada kecepatan
komputasi dan biaya yang dibutuhkan.
Teknik lain yang dapat digunakan pada CNN disebut juga dengan “Dropout”. Dropout
dapat digunakan sebagai sebuah teknik regularisasi untuk mencegah terjadinya overfit. Yang
dilakukan adalah ketika proses pelatihan gambar, beberapa unit akan dibuang secara acak, begitu
juga dengan koneksi mereka pada layer. Namun perlu diperhatikan bahwa pada tahap evaluasi,
Dropout tidak akan membuang unit tersebut, agar distribusi parameter saat evaluasi sama, atau
mendekati dengan yang ada pada tahap pelatihan.

Model CNN
Beberapa peneliti telah membuat model CNN dasar yang dapat digunakan untuk melakukan
pemrosesan gambar. Beberapa diantaranya adalah :
1. LeNet-5 dibuat oleh Yann LeCun
2. AlexNet dibuat oleh Alex Krizhevsky et al.
3. GoogLeNet dibuat oleh Szegedy pada penelitian di Google.
4. ResNet dibuat oleh Kaiming He et al. 139
 Kita akan mencoba melihat contoh dari AlexNet.

AlexNet merupakan sebuah contoh model CNN yang umum digunakan. Model ini terdiri
dari beberapa Max Pooling yang digunakan sebelum memasuki Dense Layer. Kita dapat melihat
ilustrasi dari arsitektur dari CNN berikut.

Input Conv Pool Dense Output

Selain pada ilustrasi diatas, kita juga dapat membuat model CNN seperti berikut ini.

Input Conv Conv Conv

Pool Dense Output

140
 Kita juga dapat membentuk model CNN menjadi bentuk seperti berikut ini.

Input Conv Pool Conv

Pool Dense Output

Kita dapat membuat model CNN tersebut sesuai dengan kebutuhan kita dan tergantung dari
input gambar yang diberikan. Setelah ini, kita akan mencoba untuk menuliskan sintaks untuk dapat
menggunakan Deep Learning untuk melakukan pemrosesan terhadap data gambar yang kita miliki.

Studi Kasus - Menggunakan ANN pada data MNIST

Pada studi kasus kali ini, kita akan mencoba untuk membandingkan penggunaan metode
ANN dan CNN. Data yang akan kita gunakan adalah data MNIST. MNIST (Modified National
Institute of Standards and Technology database) merupakan sebuah database yang berisikan
berbagai macam angka yang dibuat dengan menggunakan tulisan tangan. Data ini umum untuk
digunakan untuk pelatihan model Machine Learning, Deep Learning, maupun Computer Vision
karena merupakan jenis data yang tergolong masih dasar. Bentuk data MNIST tersebut adalah
seperti berikut ini.

141
 Dengan adanya 10 angka, maka kita bisa mengatakan bahwa pada data MNIST terdapat 10
macam klasifikasi. Kita akan menggunakan Deep Learning untuk membuat sebuah model untuk
menentukan apakah model dapat mengklasifikasikan gambar tersebut pada klasifikasinya yang
tepat. Dengan menggunakan PyTorch Vision, kita dapat dengan mudah mengakses data MNIST
tersebut. Jumlah data yang akan kita gunakan pada studi kasus ini adalah 60.000 gambar untuk train
data dan 10.000 gambar untuk test data.
Untuk mengerti lebih dalam mengenai data MNIST ini, tiap digit angka pada gambar dapat
digolongkan sebagai sebuah array.

Secara spesifik, ukuran array dari tiap gambar tersebut berukuran 28 x 28.

142
 Untuk melatih data tersebut, kita perlu membuat ukuran data tersebut dari berukuran 28x28
menjadi ukuran 784. Proses ini disebut flatten. Dengan demikian, kita akan memiliki 784 input,
yang berarti memiliki 784 neuron input. Kita akan memasukan 784 neuron input ini kedalam hidden
layer, untuk menciptakan 10 macam output, yang merupakan jumlah klasifikasi yang kita inginkan.
Dalam percobaan menggunakan ANN ini, dengan melakukan flattening, kita akan kehilangan
beberapa informasi 2D, seperti relasi antar pixel pada pixel sebelahnya. Pada ANN, kita akan
mengabaikan hal ini terlebih dahulu, dan mencoba membuat sebuah model. Kita akan
mendiskusikan ini ketika nanti kita mencoba membuat model yang sama dengan menggunakan
CNN.

Eksplorasi data MNIST

Kita akan mencoba untuk mengimport semua library yang akan kita gunakan. Karena kita
akan menggunakan PyTorch, kita akan import semua library yang dibutuhkan, termasuk juga
numpy dan matplotlib.

Setelah kita mengimport seluruh library yang akan digunakan, kita akan mengimport dataset
MNIST. Data ini tersedia pada PyTorch Vision. Kita akan mendownload data tersebut dalam
Google Colab kita. Kita akan meletakan data tersebut dalam Root Folder, lalu kita akan mengubah
data tersebut menjadi sebuah tensor. Perhatikan sintaksnya berikut ini.

143
 Data tersebut telah berhasil kita download dan kita simpan dalam Google Colab. Untuk
dapat melihat data tersebut, kita dapat mengakses Root Folder kita. Kita dapat mengaksesnya
dengan cara mengklik tombol tanda panah keatas berikut ini.

144
 Kita sekarang memiliki sebuah folder bernama Data. Ingat bahwa kita sebelumnya
melakukan proses download dengan menggunakan fungsi dataset.MNIST(). Ketika kita
memanggil train_data dan test_data, kita lihat bahwa kita memiliki 60.000 train_data dan juga
10.000 test_data. Kita juga melihat bahwa seluruh data kita sekarang sudah merupakan sebuah
tensor.
Kita bisa mengecek tipe data dari train_data maupun isi dari train_data. Perhatikan sintaks
berikut.

145
 Kita juga dapat mengecek ukuran dari train_data. Perhatikan sintaks berikut ini.

Kita juga dapat melihat dan menggambarkan isi dari train_data tersebut. Perhatikan contoh
gambar angka 5 berikut ini, yang telah kita ubah menjadi grayscale.

Setelah memahami bentuk data MNIST yang kita miliki, kita akan mencoba untuk
menampilkan data tersebut dalam sejumlah batch. Kita akan menggunakan DataLoader dari
PyTorch untuk membantu kita mengambil file ini dan mengacaknya. Perhatikan sintaks berikut ini.

146
 Sintaks tersebut akan mengambil data dengan sistem batch. Untuk train_data, kita akan
mengacak data tersebut. Kita akan mengambil 100 data tiap batch untuk train_data dan 500 data
tiap batch untuk test_data. Setelah ini, kita akan mencoba untuk memvisualisasikan data pada
batch pertama yang diambil.

Kita menggunakan make_grid dan fungsi numpy set_printoptions() untuk menampilkan

gambar tersebut. Lalu, untuk mengambil data pada batch pertama, kita tidak perlu mengetikkan
indeksnya satu per satu, kita bisa memanfaatkan fungsi iterasi, lalu kita akan menambahkan break
pada iterasi, sehingga data pada train_loader batch pertama akan masuk ke dalam variabel images
dan labels. Kita akan menampilkan data tersebut. Perhatikan sintaks berikut ini.

Perhatikan label dan gambar tersebut. Kita mendapati bahwa label yang dihasilkan sama
dengan angka pada gambar yang dihasilkan tersebut. Dengan demikian, kita melihat bahwa
klasifikasi pada data MNIST mengklasifikasikan data gambar angka tersebut dengan tepat. Setelah
ini, kita akan mencoba untuk membuat model Deep Learning untuk melakukan klasifikasi terhadap
data MNIST ini.

147
Membuat Neural Network
Kita akan membuat sebuah class untuk membuat model neural network kita. Perhatikan
sintaks berikut.

Class yang kita buat adalah MultilayerPerceptron. Kita menuliskan jumlah input pada
variabel in_sz sebesar 784 dan output pada variabel out_sz sebesar 10. Kita juga akan membuat dua
layer dengan jumlah neuron 120 dan 84. Kita menggunakan ReLu sebagai activation function juga.
Ketika kita menjalankan class ini nantinya, kita akan mengembalikan model tersebut dengan
menggunakan fungsi softmax() dengan dimensi = 1. Kita menggunakan softmax karena ini
merupakan sebuah klasifikasi dengan lebih dari 1 kelas. Perhatikan sintaks berikut ini.

Kita dapat mengecek jumlah parameter yang dihasilkan dari model ini. Kita bisa
menggunakan numel() yaitu number of elements untuk mengecek jumlah parameter yang
dihasilkan.

148
 Apabila kita cek total parameter yang ada pada model tersebut, kita mendapati bahwa total
parameter seluruhnya ada sekitar 105.214 parameter. Hal ini telah kita sebutkan pada bagian teori
CNN sebelumnya bahwa dengan menggunakan ANN, jumlah parameter yang dihasilkan untuk
gambar berukuran 28x28 adalah 105.214. Hal ini dikarenakan pada ANN, seluruh neuron input akan
terhubung pada seluruh layer pertama. Hal ini menyebabkan banyaknya kombinasi parameter yang
dihasilkan. Setelah ini, kita juga akan memberikan loss function dan juga optimizer. Kita
menggunakan Adam Optimizer untuk model ini.

Untuk memasukkan gambar tersebut kedalam model kita, kita perlu mengubah ukuran
gambar tersebut. Kita lihat bahwa gambar tersebut memiliki ukuran [100, 1, 28, 28]. Kita akan
mengubah 3 komponen terakhir dengan mengkalikan seluruhnya, sehingga kita akan melakukan
flatten dengan mengubah ukurannya menjadi [100, 784].

149
Melatih Model
Kita akan melatih model kita. Perhatikan sintaks berikut.

150
 Perhatikan bahwa sintaks tersebut menggabungkan proses training dan validasi secara
bersamaan, sehingga kita memiliki sintaks yang panjang. Kita akan menggunakan fungsi time()
untuk menghitung lama waktu pelatihan model. Kita juga memberikan nilai episode sebanyak 10.
Kita juga membuat beberapa list yang berfungsi sebagai sebuah tracker untuk kita mengetahui
jumlah loss dan correct.
Pada proses pelatihan, kita akan memasukan nilai X_train dalam model tersebut, lalu
dengan menggunakan fungsi criterion, kita akan mengecek jumlah loss. Dengan menggunakan
variabel batch_corr, kita menghitung jumlah predicted yang nilainya sama dengan y_train, yang
menandakan jumlah prediksi yang tepat. Kita juga menuliskan optimizer dan loss function setelah
itu, lalu untuk tiap 200 batch, kita akan mengeluarkan pencatatan mengenai epoch, batch, loss, dan
akurasi.
Pada proses yang sama, kita juga akan melakukan validasi. Untuk melakukan validasi,
sintaks yang kita gunakan mirip dengan yang kita gunakan pada X_train, namun kita menggunakan
X_test dan bukan X_train. Ketika kita jalankan sintaks tersebut, kita akan mendapatkan hasil
seperti berikut ini.

151
Evaluasi Performa Model
Kita akan mengevaluasi performa dari model tersebut dengan cara melakukan plot terhadap
train_losses dan test_losses. Perhatikan sintaksnya berikut ini.

Dengan sintaks diatas, kita mendapati jumlah loss yang dihasilkan dari train_data dan
test_data. Kita lihat bahwa nilai test memiliki loss yang lebih besar dibandingkan train. Hal ini
cukup wajar apabila kita menggunakan data sebenarnya nantinya, karena kita melakukan validasi
terhadap data yang belum pernah dilihat oleh model sebelumnya, sehingga kemungkinan untuk loss
akan lebih besar. Kita lihat juga bahwa pada train data, nilai loss cukup rendah pada episode 3.
Mungkin kita bisa mempertimbangkan untuk menghentikan proses pelatihan pada episode 3 untuk
mendapatkan nilai loss yang lebih baik. Selain loss, kita juga akan melihat jumlah benar yang
dihasilkan proses pelatihan model kita. Perhatikan sintaksnya berikut ini.

152
 Akurasi tersebut merupakan akurasi yang sama seperti ketika kita melakukan print terhadap
log sebelumnya. Nilai akurasi pada proses pelatihan data terbilang cukup baik, mendekati nilai
100% pada episode terakhir. Kita dapat lihat pada test data bahwa nilai akurasi yang dihasilkan
meningkat, namun sekitar pada episode ke 4, kita melihat bahwa akurasinya tidak terlalu banyak
bertambah. Namun dengan nilai akurasi yang tinggi, kita bisa mempertimbangkan nantinya apa kita
akan melakukan validasi hanya sebanyak 4 episode saja dengan melihat hasil akurasinya ini.
Berikutnya, kita akan mencoba untuk menggunakan data lain sebagai validasi pada model
kita ini. Perhatikan sintaks berikut ini.

Sekarang kita memasukan seluruh 10.000 data sebagai sebuah batch sekaligus. Ketika kita
mengecek nilai akurasi dari model tersebut, kita mendapati bahwa model kita bisa melakukan
prediksi dan memiliki tingkat akurasi sebesar 97,74%. Untuk melihat hasil klasifikasi tersebut, kita
bisa menggunakan confusion matrix untuk melihat hasilnya. Perhatikan sintaks berikut ini.

153
 Ingat bahwa pada confusion matrix, nilai diagonal merupakan nilai yang sesungguhnya. Kita
lihat pada tiap kelas klasifikasi, model kita dapat memprediksi dengan tepat dengan rata - rata diatas
900 data dengan tepat. Hal ini tercermin dari tingkat akurasinya yang berupa 97,4%. Kita dapat
bermain dengan parameter dan juga jumlah neuron yang digunakan apabila kita tidak puas dengan
hasil akurasi yang dihasilkan, dan juga menginginkan hasil akurasi lain ataupun melakukan
eksperimen lainnya. Setelah ini, kita akan mencoba untuk melakukan hal yang sama namun dengan
menggunakan CNN. Kita akan mencoba untuk mengurangi jumlah parameter yang dihasilkan dan
juga mempercepat proses komputasi.

Studi Kasus - Menggunakan CNN pada data MNIST

Kita telah mencoba untuk membuat sebuah model ANN untuk melakukan klasifikasi
terhadap data MNIST. Dari percobaan yang kita lakukan sebelumnya, kita mendapatkan nilai
akurasi yang cukup tinggi, yaitu 97,4% untuk memprediksi sebuah data baru yang belum pernah
dilihat oleh model. Namun dengan menggunakan ANN, kita mengetahui bahwa jumlah parameter
yang kita gunakan sebanyak 105.214 parameter, yang cukup banyak untuk gambar berukuran hanya
28x28 saja. Kita juga telah melihat pada percobaan bahwa waktu yang dibutuhkan untuk
menjalankan model tersebut berkisar antara 2,4 menit. Berdasarkan teori CNN yang telah kita bahas
sebelumnya, kita mengetahui bahwa kelemahan ANN adalah memiliki parameter yang lebih banyak
karena seluruh neuron input akan saling terhubung dengan seluruh neuron pada layer, sehingga
menyebabkan jumlah parameter yang banyak dan juga waktu komputasi yang lebih lama. Kita akan
mencoba untuk menggunakan CNN untuk mendapat parameter yang lebih sedikit dan juga waktu
komputasi yang lebih cepat.

154
 Kita akan mengimport seluruh library yang akan kita gunakan pada percobaan CNN ini.
Setelah itu, sama seperti yang kita lakukan pada metode ANN sebelumnya, kita akan mencoba
untuk mendownload data MNIST yang akan kita gunakan. Perhatikan sintaksnya berikut ini.

Data tersebut akan terdownload pada Root Folder kita, kedalam sebuah folder yang
bernama Data. Setelah itu, kita akan mengambil data tersebut dengan menggunakan fungsi
DataLoader(). Pada percobaan CNN ini, kita akan mencoba untuk menggunakan batch_size yang
lebih kecil, yaitu 10. Kita bisa bereksperimen dan mencoba nilai lain pada batch_size ini. Kita juga
akan mengecek ukuran dari gambar tersebut dengan menggunakan fungsi shape.

155
 Kita akan memahami dahulu lebih lanjut mengenai model CNN yang akan kita buat. Skema
model yang akan kita buat adalah seperti berikut ini.

Input Conv Pool Conv

Pool Dense Output

Model CNN yang akan kita buat adalah dengan memberikan sebuah convolutional layer,
lalu memberikan sebuah Max Pooling, dilanjutkan dengan convolutional layer kedua, lalu
memberikan sebuah Max Pooling kembali, sebelum dimasukan ke dalam neural network. Kita akan
membahas tiap layer satu per satu, sebelum kita membangun sebuah kelas ConvolutionalNetwork
yang akan kita gunakan untuk model CNN kita. Perhatikan sintaks berikut untuk penjelasan
mengenai convolutional layer pertama.

Untuk membuat sebuah convolutional layer, kita menggunakan fungsi nn.Conv2d.

Parameter yang kita berikan disini adalah nn.Conv2d(channel_input, channel_output,
ukuran_kernel, step_size). Disini kita membuat variabel conv1 yang berisikan convolutional layer
kita, yang berisi parameter nn.Conv2d(1,6,3,1). Angka 1 pertama merupakan jumlah channel input.
Karena gambar kita grayscale, kita akan memasukan jumlah input adalah 1 karena ukurannya 1
dimensi. Angka 6 merupakan jumlah output yang kita inginkan. Kita bisa bereksperimen dengan
angka ini dan mencoba opsi lainnya. Angka 3 merupakan ukuran kernel yang digunakan. Angka 1
terakhir merupakan stride atau banyaknya pergeseran kernel yang dilakukan.

156
 Perhatikan ketika kita melewatkan gambar input kita ke dalam model tersebut, kita
mendapatkan hasil seperti berikut.

Ingat bahwa sebelumnya, ukuran gambar kita adalah 28 x 28. Pada hasil keluaran sintaks
diatas, kita melihat bahwa sekarang ukurannya menjadi 26 x 26. Hal ini seperti yang telah kita bahas
pada bagian teori sebelumnya, bahwa dengan menggunakan CNN, kita berkesempatan untuk
kehilangan sebagian dari informasi. Namun karena data MNIST yang kita gunakan ini bagian
ujungnya merupakan background berwarna gelap yang tidak relevan terhadap fitur, kita bisa
mengabaikannya. Salah satu cara untuk mencegah terjadinya kehilangan fitur apabila kita
menggunakan data gambar yang mungkin lebih kompleks, adalah dengan menambahkan parameter
padding pada saat kita membuat fungsi nn.Conv2d(). Dengan menambahkan padding, kita bisa
mencegah adanya kehilangan data.
Sesuai dengan skema yang telah kita buat sebelumnya, kita akan memasukan hasil dari
convolutional layer pertama ke dalam max pooling pertama. Kita menggunakan fungsi
F.max_pool2d() untuk membuat max pooling, dengan parameter yang bisa kita berikan adalah
F.max_pool2d(gambar, ukuran_kernel, step_size). Perhatikan penulisan sintaksnya berikut ini.

Perhatikan bahwa sekarang ukuran data kita berubah kembali menjadi 13x13. Hal ini
dikarenakan kita menggunakan kernel berukuran 2x2. Sehingga dari total pixel berukuran 26,
dengan menggunakan max pooling maka akan tereduksi menjadi 13.

157
 Sesuai dengan skema yang kita miliki, kita akan memberikan convolutional layer kedua kita.
Perhatikan sintaksnya berikut ini.

Sama seperti yang terjadi ketika kita menggunakan convolutional layer pertama. Kita akan
kehilangan informasi 2 pixel, sehingga dari jumlah pixel kita yang awalnya adalah 13, sekarang
menjadi 11. Setelah ini, kita akan melanjutkan skema kita dengan memberikan sebuah max pooling.
Perhatikan sintaksnya berikut ini.

Dengan memberikan 2 kali convolutional layer dan 2 kali max pooling, sekarang kita hanya
memiliki gambar dengan ukuran pixel 5x5. Gambar ini akan kita masukan kedalam neural network
kita selanjutnya. Karena pada neural network kita hanya memiliki 2 input untuk gambar grayscale,
maka kita akan mengubah dimensinya. Perhatikan sintaks untuk mengubah dimensinya.

Dari hasil percobaan dan informasi yang telah kita bahas sebelumnya, kita mengetahui
bahwa ukuran pixel pada gambar kita pada akhirnya akan menjadi ukuran 5x5 sebelum dimasukan
pada neural network. Informasi ini yang akan kita gunakan untuk membangun model CNN kita
secara keseluruhan, dan membuat kelas baru yang dinamakan ConvolutionalNetwork(). Perhatikan
penulisan sintaksnya berikut ini.

158
 Perhatikan kelas diatas merupakan keseluruhan model CNN yang akan kita bangun. Kita
akan menggunakan dua Dense layer dengan ukuran 120 dan 84 neuron. Untuk menjalankan model
tersebut, kita akan memasukkannya kedalam variabel model. Perhatikan sintaks berikut ini.

Kita akan mengecek jumlah parameter yang digunakan untuk membuat model CNN. Kita
ingat bahwa pada pembahasan mengenai teori CNN, model CNN akan memiliki jumlah parameter
yang lebih sedikit dibandingkan ANN. Setelah kita melakukan pengecekan, pada ANN kita
memiliki jumlah parameter sebanyak 105.214, sedangkan dengan model CNN kita hanya
memerlukan parameter sebanyak 60.074.

159
 Jumlah parameter yang terbentuk ketika kita menggunakan CNN hanya sekitar 60% dari
yang kita butuhkan pada ANN. Hal ini telah membuktikan bahwa CNN memiliki parameter yang
jauh lebih sedikit dibandingkan ANN. Hal ini disebabkan karena tidak semua neuron pada CNN
akan saling terhubung, dan hanya yang memiliki fitur lokal saja yang akan terhubung, sehingga
membuat parameter yang digunakan pada CNN bisa lebih sedikit dibandingkan dengan ANN.
Setelah kita mengecek jumlah parameter tersebut, kita akan membuat loss criterion, yaitu
menggunakan CrossEntropyLoss(), karena yang kita lakukan ini merupakan sebuah klasifikasi.
Kita juga akan memberikan sebuah optimizer, yang akan kita gunakan adalah Adam Optimizer
dengan nilai learning rate sebesar 0,001. Kita juga dapat bereksperimen lebih lanjut untuk
mengetahui nilai learning rate yang efektif. Kita ingat pada materi mengenai Deep Learning bahwa
learning rate yang lebih tinggi akan mempercepat proses pelatihan, namun akurasi yang dihasilkan
mungkin tidak akan setinggi apabila kita menggunakan nilai learning rate yang lebih rendah. Saat
pembuatan modul ini, nilai 0,001 memiliki performa yang baik untuk model yang kita buat ini.
Setelah ini, kita akan melakukan proses pelatihan terhadap train_data dan juga proses
validasi terhadap test_data secara bersamaan. Penulisan sintaks yang akan kita gunakan mirip
seperti yang kita gunakan pada ANN. Jumlah episode yang akan kita gunakan adalah 5, untuk
mempercepat proses pelatihan yang dilakukan. Perhatikan sintaksnya berikut ini.

160
161
 Proses pelatihan dan validasi yang dilakukan sama seperti yang kita lakukan pada ANN,
sehingga penjelasan lebih detailnya dapat dilihat pada bagian pembahasan MNIST dengan ANN.
Hal yang akan lebih dibahas disini adalah mengenai durasi dan hasil dari performa yang dihasilkan
dari sintaks tersebut. Perhatikan hasil output dari sintaks tersebut.

Perhatikan bahwa durasi yang dihasilkan lebih lama dibandingkan kita menggunakan ANN.
Hal ini kemungkinan dapat disebabkan karena kita menggunakan nilai batch_size yang jauh lebih
kecil dibandingkan dengan ANN, sehingga CNN memerlukan waktu lebih untuk melakukan
pelatihan dan validasi. Namun disini kita dapat melihat performa dari loss yang dihasilkan. Kita
lihat bahwa loss yang dihasilkan nilainya sangat kecil, dan bahkan jauh lebih kecil dibandingkan
ANN. Kita dapat mencoba untuk memvisualisasikan hasil dari loss dan juga akurasi dari model
CNN kita. Perhatikan sintaksnya berikut ini.

162
 Kita dapat lihat, pada proses pelatihan, loss kita berkurang banyak pada episode ke 2. Kita
juga melihat pada proses validasi, bahwa kita memiliki jumlah loss hampir mendekati angka 0, yang
dimana model kita hampir berhasil memprediksi seluruh nilai dengan benar. Performa CNN ini
dapat terbilang jauh lebih baik dan menghasilkan nilai yang jauh lebih baik dibandingkan dengan
CNN. Kita juga akan mencoba mengecek hasil akurasi yang dihasilkan dari model ini.

163
 Pada hasil akurasi, kita mendapatkan hasil yang mirip dengan loss, dimana akurasi dari
proses pelatihan sangat tinggi, bahkan hampir mencapai 100% pada episode ke 5. Sedangkan pada
proses validasi, kita juga memiliki performa yang cukup tinggi, dengan rata - rata sekitar 98%.
Dengan hasil yang baik, kita akan mencoba untuk melakukan sebuah prediksi terhadap data baru
yang belum pernah dilihat oleh model. Perhatikan sintaks berikut ini.

Dengan menggunakan data baru yang belum pernah dilihat model sekalipun, kita
mendapatkan nilai akurasi sebesar 98,9%, hampir mendekati 99%. Hal ini terbukti bahwa dengan
menggunakan CNN, kita dapat mendapatkan model dengan hasil akurasi yang lebih tinggi
dibandingkan dengan ANN. Kita juga dapat mengecek confusion matrix dari hasil menggunakan
data baru tersebut. Perhatikan sintaksnya berikut ini.

164
 Pada confusion matrix, kita mendapatkan bahwa hasil klasifikasinya hanya meleset sedikit
saja, dan rata - rata memiliki jumlah benar sebanyak 1000 per klasifikasinya. Hal ini membuktikan
bahwa dengan menggunakan CNN dapat lebih efektif dalam mengolah data yang berupa gambar.
Pada bagian selanjutnya, kita akan mencoba untuk mengolah data gambar yang sebenarnya.
Data gambar ini merupakan gambar dengan warna RGB, yang memiliki dimensi lebih banyak
dibandingkan dengan gambar RGB dan memiliki tantangan yang jauh lebih sulit dibandingkan
dengan gambar grayscale.

Studi Kasus - Menggunakan CNN pada gambar RGB

Ketika kita mengolah gambar dengan menggunakan data MNIST, gambar yang kita olah
merupakan sebuah gambar grayscale. Pada praktiknya, gambar yang umum beredar merupakan
gambar berwarna dan bukan gambar hitam putih. Untuk itu, kita perlu mencoba untuk melakukan
pengolahan data terhadap gambar yang berwarna.
Pada studi kasus kali ini, kita akan mencoba untuk mengolah data gambar menggunakan
gambar yang berwarna, atau menggunakan gambar RGB. Dari gambar tersebut, kita akan
melakukan klasifikasi sederhana agar model yang kita buat dapat memprediksi dan mengambil fitur
yang berada dalam gambar tersebut. Untuk melakukan prediksi terhadap gambar yang ada di sekitar
kita, kita akan melatih model CNN tersebut dengan beberapa gambar yang akan digunakan sebagai
sebuah train data. Gambar tersebut dapat kita temukan pada Google Drive berikut: CATS_DOGS.
Silahkan download gambar tersebut dari Google Drive lalu sesuaikan lokasi penyimpanannya.
Perhatikan bahwa ukuran dari file tersebut melebihi 700 MB karena jumlah gambar keseluruhannya
ada 25.000 gambar yang berupa kumpulan gambar kucing dan anjing. Dalam folder tersebut, kita
akan menemukan folder berikut ini.

165
 Dalam folder tersebut, kita akan menemukan train data dan test data. Apabila kita mengecek
train data, maka kita akan menemukan data gambar kucing dan anjing yang dipisahkan antar folder.

Kita juga akan menemukan hal yang sama pada test data.

166
 Kita akan melatih model kita dengan menggunakan train data agar model yang kita miliki
dapat membedakan gambar anjing dan kucing. Lalu kita akan menguji model tersebut dengan
memberikan test data anjing dan kucing secara acak. Kita akan melihat seberapa akurat model
tersebut dapat mendeteksi mana gambar yang merupakan anjing dan mana yang merupakan kucing.
Sebelum itu, kita akan memasukkan library yang kita butuhkan terlebih dahulu. Perhatikan sintaks
berikut ini.

Setelah ini, kita akan mengubah gambar kita dengan menggunakan beberapa fitur dasar dari
image processing, seperti rotasi, flip, crop, dan lainnya. Hal ini ditujukan untuk memperkaya
informasi untuk model, karena dengan teknik seperti flip, kita seakan menambahkan sebuah
informasi gambar baru, karena dengan flip akan memiliki nilai pixel yang berbeda dari gambar asli.
Kita akan membuat transformasi ini untuk train data dan test data kita. Perhatikan sintaksnya
berikut ini.

Pada metode CNN sebelumnya, kita hanya menggunakan ToTensor() untuk mengubah
gambar numpy menjadi tensor. Kita sekarang menggunakan Compose() karena kita mau
memberikan lebih dari 1 transformasi. Transformasi tersebut akan dijalankan secara berurutan.

167
 Kita memiliki beberapa transformasi yang digunakan. Berikut merupakan penjelasan singkat
dari kegunaan masing - masing transformasi :
1. transforms.RandomRotation() : Akan memutar gambar sebanyak sudut yang dituliskan
didalamnya. Arah putar ini akan ditentukan secara acak oleh fungsi tersebut.
2. transforms.RandomHorizontalflip() : Akan melakukan flip secata horizontal. Angka yang
dituliskan dalam fungsi akan menentukan probabilitas dari eksekusi fungsi ini. Probabilitas yang
tinggi akan menyebabkan kemungkinan fungsi ini dieksekusi menjadi lebih tinggi tiap
prosesnya.
3. transforms.Resize() : Akan mengubah ukuran gambar sehingga nilai pixel maksimum menjadi
sesuai angka yang dituliskan. Gambar akan dilakukan stretching apabila diperbesar dan
dilakukan compressing apabila diperkecil.
4. transforms.CenterCrop() : Angka ukuran pixel akan dituliskan dalam fungsi tersebut. Setelah
itu, fungsi tersebut hanya akan mengambil gambar bagian tengah dari rentang pixel tersebut.
5. transforms.ToTensor() : Fungsi ini akan merubah gambar numpy menjadi sebuah gambar
tensor.
6. transforms.Normalize() : Fungsi ini akan melakukan normalisasi terhadap nilai pixel
didalamnya. Argumen pertama merupakan nilai mean dari pixel yang diinginkan, lalu argumen
berikutnya merupakan nilai standar deviasi dari pixel yang diinginkan. Nilai yang tertera pada
contoh tersebut merupakan nilai yang digunakan dari hasil riset para peneliti sebelumnya.
Keseluruhan fungsi transforms yang telah disebutkan diatas merupakan bagian dari
Data Augmentation yang sering digunakan pada materi Deep Learning dalam PyTorch, dimana
bertujuan untuk mencegah terjadinya overfitting ketika kita melakukan pelatihan terhadap model.
Setelah ini, kita akan mengambil gambar anjing dan kucing dari Google Drive. Kita akan
menggunakan fungsi datasets yang dimiliki PyTorch untuk membantu kita menggabungkan data pada
folder Cats dan folder Dogs pada tiap train dan test. Kita juga akan mengambil data mengenai kelas
mereka, yang menunjukkan klasifikasi dari gambar yang kita miliki. Perhatikan sintaks berikut ini.

168
 Apabila kita mengecek jumlah data yang ada pada train data dan test data, kita akan melihat
jumlah keseluruhannya ada sekitar 25.000 gambar.

Setelah ini, kita akan mencoba untuk menampilkan data yang ada pada tiap batch.
Perhatikan bahwa pada DataLoader yang kita buat sebelumnya, kita memiliki 100 data. Dengan
menggunakan normalisasi, kita akan menampilkan gambar pada batch pertama tersebut. Nilai
normalisasi yang digunakan merupakan nilai standard, dan kita bisa menuliskan ukurannya sesuai
dengan yang kita inginkan. Perhatikan sintaksnya berikut ini.

169
 Perhatikan disini kita menggunakan np.transpose untuk menampilkan gambar tersebut
dengan mengubahnya kembali dari tensor menjadi numpy, beserta dengan menggunakan
plt.imshow. Arti dari angka (1,2,0) pada np.transpose adalah urutan penulisan indeks. Hal ini
disebabkan karena plt.imshow() hanya dapat menampilkan gambar dengan urutan parameter yang
diberikan adalah plt.imshow((width, height, color channel)) sedangkan pada tensor urutan
indeksnya adalah (color channel, width, height). Kita menggunakan transpose untuk mengubah
urutan ini agar plt.imshow() bisa membaca gambar tersebut dengan parameter yang benar. Dengan
menjalankan sintaks tersebut, kita akan mendapatkan gambar berikut ini.

Setelah ini kita akan mencoba untuk membuat model CNN kita. Kita akan membuat layer
CNN pertama dengan input 3 neuron (sesuai jumlah dimensi color channel) dengan 6 output
neuron, ukuran kernel 3x3 dan step size sebanyak 1. Kita juga akan membuat layer CNN kedua
dengan ukuran 6 (sesuai output dari layer pertama), memiliki 16 output neuron, ukuran kernel 3x3
dan step size 1. Kita juga membuat sebuah fungsi Dense dengan ukuran 54 x 54 x 16, dengan 120
output neuron. Perhatikan nilai 54 ini didapat dari perhitungan sederhana. Karena kita akan
membuat model yang sama seperti pada gambar grayscale sebelumnya, dimana kita akan membuat
model dengan skema CNN Layer - Max Pooling - CNN Layer - Max Pooling. Kita tahu bahwa
dengan model CNN tanpa diberikan padding, akan kehilangan 2 pixel sehingga dari ukuran 224
akan menjadi 222. Max Pooling akan membuang setengahnya sehingga keluarannya menjadi 111.
CNN layer kedua akan kembali mengurangi 2 sehingga tersisa 109, lalu Max Pooling terakhir akan
mengurangi lagi menjadi 54,5 (54).

170
 Setelah itu kita akan menambahkan sebuah layer lagi dengan ukuran 120 dan output 84
neuron. Terakhir kita akan memberikan sebuah layer terakhir dengan ukuran 84 dan output 2
neuron, yang menandakan dua macam output klasifikasi yaitu CAT atau DOG. Perhatikan
penulisan sintaks seluruhnya berikut ini.

Kita akan membuat model ini dan memasukkannya ke dalam variabel CNNmodel. Kita juga
akan memberikan loss function yaitu nn.CrossEntropyLoss() karena merupakan proses klasifikasi,
dan juga memberikan Adam Optimizer dengan nilai learning rate 0,001.

171
 Setelah model tersebut terbentuk, kita akan mengecek jumlah parameter yang dihasilkan dari
model CNN tersebut. Perhatikan sintaks berikut.

Perhatikan bahwa pada model CNN tersebut kita memiliki lebih dari 5,5 juta parameter.
Bayangkan apabila kita menggunakan ANN, parameter yang dihasilkan bisa lebih banyak lagi
karena ANN menghubungkan seluruh layer yang ada satu sama lain.
Setelah ini, kita akan melakukan proses pelatihan model kita. Kita akan melakukan proses
iterasi yang sama seperti yang kita lakukan pada gambar grayscale. Pada proses pelatihan kali ini,
karena kita memiliki jumlah data yang besar yaitu 25.000 gambar, kita akan membatasi proses
pelatihan dan validasi yang akan kita lakukan dengan proses pelatihan sebanyak 800 iterasi saja. Hal
ini disebabkan proses ini akan berlangsung sangat lama dan bahkan dapat melebihi 15 menit untuk
pelatihannya sendiri. Perhatikan penulisan sintaks untuk pelatihannya berikut ini.

172
173
 Perhatikan proses pelatihan ini sangatlah lama, karena model CNN yang kita buat perlu
membaca banyak sekali gambar. Ketika kita menjalankan model tersebut, kita akan melihat output
berikut ini.

Setelah proses pelatihan tersebut selesai, kita akan coba untuk mengecek hasil dari pelatihan
tersebut. Kita akan mencoba untuk menggambarkan nilai loss yang dihasilkan dari proses pelatihan
dan validasi tersebut. Berikut ini sintaks yang digunakan.

Perhatikan bahwa nilai loss berkurang untuk tiap episode yang berjalan. Kita juga akan
melihat validasi yang kita lakukan. Perhatikan sintaks berikut ini.

174
 Perhatikan nilai akurasi tersebut. Pada episode terakhir, kita memiliki nilai 5 untuk validasi.
Hal ini berarti model yang kita buat memiliki tingkat validasi sebesar 50%. Nilai ini didapatkan
dengan menggunakan sintaks berikut ini.

Nilai 50% bukan merupakan nilai yang baik. Hal ini berarti model kita memiliki
kemungkinan seimbang antara memprediksi dengan benar atau salah. Kita bisa memperpanjang
proses pelatihan untuk membuat model kita belajar lebih baik lagi, namun perlu diperhatikan bahwa
waktu yang diperlukan akan lebih lama. Apabila kita ingin menyimpan model itu untuk digunakan
lagi selanjutnya, kita bisa menyimpannya dalam sebuah file pt. Perhatikan sintaksnya berikut ini.

Kita akan mencoba untuk melakukan prediksi dengan menggunakan model yang kita miliki
tersebut. Untuk itu, kita akan mengambil sebuah gambar yang kita miliki secara acak. Pada contoh
berikut ini, kita akan mencoba untuk mengambil acak sebuah gambar dengan nomor indeks 2023,
kita akan mencoba untuk melihat terlebih dahulu gambar apakah gambar tersebut.

175
 Gambar pada indeks nomor 2023 pada test data merupakan gambar kucing. Kita akan
mencoba untuk menggunakan model kita apakah model tersebut dapat melakukan klasifikasi
dengan tepat. Perhatikan sintaksnya berikut ini.

Perhatikan bahwa walaupun dengan tingkat akurasi 50%, model yang kita miliki berhasil
untuk memprediksi bahwa gambar tersebut merupakan gambar kucing. Kita bisa mencoba untuk
melakukan prediksi dengan gambar lain diluar dari seluruh data yang kita miliki. Namun perlu
diperhatikan karena kita memiliki tingkat akurasi 50%, mungkin kita dapat melatih model kita
dengan baik agar memiliki tingkat prediksi yang jauh lebih baik lagi.

176
 2. Generative Adversarial Network (GAN)
Generative Adversarial Network (GAN) merupakan sebuah metode yang diciptakan pada
tahun 2014 oleh Ian Goodfellow et al. Metode ini menggunakan dua network yang saling diadu
untuk menghasilkan sebuah data. Network pertama yang dimaksud ini adalah sebuah generator.
Generator akan menerima noise acak (biasanya Gaussian) dan akan menghasilkan sebuah data,
biasanya berupa gambar. Network kedua adalah discriminator. Discriminator akan berperan untuk
mengambil data dari gambar yang sesungguhnya dan juga gambar “palsu” yang dihasilkan oleh
generator. Dari definisi ini, kita sudah bisa membayangkan bagaimana cara GAN ini bekerja.
GAN ini berfungsi untuk membedakan mana gambar yang palsu yang dihasilkan oleh
generator, dan gambar asli yang didapat dari dataset. Perhatikan ilustrasi berikut ini.

Gambar
Noise Generator
Palsu

Discriminator Asli / Palsu?

Gambar Gambar
Asli Asli

Dari klasifikasi yang ditentukan oleh discriminator, kita akan mengembalikan feedback
tersebut kepada generator, sehingga pada proses pelatihan berikutnya, generator dapat menciptakan
lagi gambar secara acak yang mendekati gambar asli. Proses ini dilakukan terus secara berulang
sampai discriminator yang kita miliki tidak lagi bisa membedakan mana gambar yang dibuat oleh
generator dan yang merupakan gambar asli.
Proses pelatihan yang dilakukan adalah pertama akan melatih discriminator, lalu kita akan
melatih generator. Pada proses pelatihan discriminator, gambar asli akan digabungkan dengan
gambar palsu dari generator. Discriminator akan dilatih untuk membedakan gambar asli dari
gambar palsu (backpropagation hanya dilakukan pada pembobotan discriminator)

177
 Pada proses di generator, kita akan menghasilkan gambar “palsu” dengan menggunakan
generator. Kita hanya akan memberikan label “asli” atau klasifikasi biner 1 untuk gambar ini. Hal
ini dilakukan agar generator dan discriminator “percaya” bahwa gambar yang dihasilkan oleh
generator ini adalah gambar “asli” ketika dibandingkan, sedangkan pada kenyataannya gambar
tersebut merupakan gambar palsu yang dihasilkan oleh generator. Karena kita memberikan label 1,
kita hanya akan melakukan backpropagation untuk pembobotan dari generator ini saja.
Perhatikan pada skema kita sebelumnya, bahwa generator tidak pernah melihat gambar asli.
Generator bisa menghasilkan gambar “palsu” tersebut berdasarkan gradien yang dikembalikan oleh
discriminator. Di saat yang sama, discriminator juga akan memiliki performa yang makin baik pada
tiap fase pelatihan, sehingga gambar yang dihasilkan oleh generator akan semakin baik.
Walaupun metode ini dapat menghasilkan sebuah gambar, metode ini memiliki beberapa
kelemahan. Kelemahan yang utama adalah pada permasalahan perhitungan, dimana GAN tidak
memahami lokalisasi. Artinya adalah ada kemungkinan GAN dapat menciptakan lebih dari satu
gambar objek pada gambar yang sama, dimana sebenarnya kita hanya ingin ada satu objek saja pada
gambar tersebut. Selain itu, ketika generator menciptakan sebuah gambar, misalkan gambar wajah
yang banyak yang digunakan untuk “membohongi” discriminator, discriminator mungkin hanya
dapat menebak satu gambar wajah. Walaupun GAN mendeteksi dengan tepat bahwa ada gambar
wajah pada gambar asli, tapi ketika menghadapi banyak gambar wajah dalam sebuah gambar, GAN
hanya dapat menghasilkan 1 gambar wajah saja. Hal ini dapat kita hindari dengan menggunakan
Deep Convolutional GAN (DCGAN). Namun metode DCGAN ini memiliki tingkat kesulitan yang
lebih kompleks dibandingkan dengan GAN. Kelemahan terakhir adalah sulitnya untuk menentukan
berapa banyak epoch yang harus digunakan untuk melatih, karena kita tahu bahwa gambar yang
dihasilkan sudah pasti merupakan gambar “palsu”.
Kelemahan lainnya adalah mengenai perspektif, dimana GAN sulit untuk beradaptasi pada gambar
3D.

178
 Sebagai kesimpulan, GAN yang merupakan salah satu model generative AI ini dibentuk
untuk mengatasi permasalahan kesulitan perhitungan probabilitas yang muncul. Selain itu GAN ini
juga diciptakan untuk membantu mengatasi kesulitan untuk menggunakan unit linear untuk
keperluan generative. Singkatnya, estimasi parameters dari discriminative AI models (seperti model
klasifikasi) jauh lebih mudah dibuat daripada di generative AI models. Karenanya, Ian Goodfellow,
et. al. mengusulkan GAN yang terinspirasi dari teori zero-sum game (di Game Theory). Penjelasan
lebih lengkap mengenai teori GAN dapat diakses pada paper resmi pada link berikut ini.

Studi Kasus - Menggunakan GAN pada data MNIST

Pada kenyataannya, banyak model GAN yang digunakan oleh banyak orang untuk membuat
sebuah gambar baru hasil dari produksi sebuah komputer. Pada contoh kali ini, kita hanya akan
mencoba untuk membuat gambar yang sederhana, dengan menggunakan data MNIST yang telah
kita gunakan sebelumnya pada saat membahas materi mengenai CNN. Pada contoh ini juga, kita
akan menggunakan library tensorflow untuk membuat GAN. Pertama, kita akan memanggil
seluruh library yang akan digunakan pada contoh ini.

Perhatikan bahwa pada CNN sebelumnya kita menggunakan PyTorch untuk mengambil
data MNIST. Pada contoh kali ini, kita akan mengambil data MNIST ini dari library
tensorflow.keras.datasets yang sebelumnya telah disediakan pada tensorflow. Apabila kita
mencoba untuk melihat bentuk X_train dan y_train, perhatikan sintaks berikut.

179
 Gambar tersebut disimpan dalam X_train sedangkan nilainya disimpan dalam y_train. Kita
mengetahui bahwa X merupakan sebuah input gambar sedangkan nilai y adalah nilai klasifikasi dari
gambar tersebut. Untuk mempermudah contoh kita, kita hanya akan memilih satu buah angka saja,
yaitu angka 0. Kita bisa menuliskan sintaks berikut.

180
 Kita bisa mencoba untuk mengecek bentuk-bentuk angka 0 tulisan tangan tersebut, dengan
cara mencoba untuk merubah - rubah indeks, untuk memiliki gambaran mengenai bagaimana bentuk
data input yang kita miliki.

Setelah ini, kita akan mencoba untuk membuat sebuah generator dan discriminator, sesuai
yang telah kita bahas pada bagian teori sebelumnya. Perhatikan sintaksnya berikut ini.

Kita akan menggunakan beberapa library dari tensorflow.keras.layers seperti Dense yang
digunakan untuk membuat layer, Reshape untuk mengubah ukuran input, dan Flatten juga untuk
mengubah ukuran input. Kita juga akan memanggil model Sequential untuk layer kita. Model
discriminator yang akan kita buat akan memiliki 2 hidden layer di dalamnya, yang masing - masing
memiliki 150 dan 100 neuron. Karena gambar MNIST memiliki ukuran 28x28, maka kita akan
menambahkan sebuah layer input di awal dengan menggunakan Flatten untuk mengubahnya
menjadi 2 dimensi.

181
 Kita juga akan menambahkan sebuah layer output di akhir yang hanya memiliki 1 neuron
saja. Setelah kita membuat model tersebut, kita akan melakukan compile pada discriminator kita
dengan memberikan loss function yaitu binary_crossentropy karena model kita merupakan model
klasifikasi, dan memberikan Adam Optimizer. Perhatikan disini apabila kita membuat hidden layer
semakin kompleks, maka akan lebih sulit bagi generator untuk “membohongi” discriminator.
Setelah membuat discriminator, kita akan membuat generator. Generator yang kita buat ini
memiliki komponen yang sama ketika kita membuat sebuah decoder pada materi Deep Learning
yaitu Autoencoder. Perhatikan sintaksnya berikut ini.

Variabel encoding_size merupakan jumlah neuron yang berada ditengah pada saat kita
membuat Autoencoder, atau dengan kata lain merupakan jumlah input bagi decoder. Ingat bahwa
pada Autoencoder, sebuah decoder berfungsi untuk membuat jumlah neuron output yang lebih
banyak dari jumlah inputnya. Disini kita akan membuat model dengan jumlah neuron dari 100,
menjadi 150, lalu menjadi 784 (kebalikan dari discriminator). Kita memilih 784 pada output agar
nilai tersebut dapat kita ubah dengan menggunakan Reshape agar menjadi ukuran dua dimensi
dengan ukuran 28x28 (784).
Setelah kita membuat discriminator dan generator, kita akan menggabungkan keduanya
untuk membuat GAN secara keseluruhan.

182
 Perhatikan disini kita menuliskan discriminator.trainable = False. Arti dari sintaks ini
adalah kita tidak ingin discriminator untuk dilakukan pelatihan. Dengan sintaks ini, ini akan
mencegah agar ketika kita melakukan compile, discriminator tidak akan ada proses pelatihan
didalamnya.
Setelah model GAN ini selesai dilakukan compile, maka kita akan menyiapkan data kita.
Perhatikan sintaks berikut ini.

Kita akan membuat batch_size berukuran 32 dan mengambil data X_train kita yang
memiliki klasifikasi nilai 0. Kita menggunakan fungsi
tf.data.Dataset.from_tensor_slices(data).shuffle(buffer_size=1000) untuk mengacak train_data
tersebut. Kita lihat bahwa data tersebut sekarang sudah merupakan data acak. Terakhir kita akan
menuliskan dataset tersebut dalam bentuk batch, lalu kita menambahkan parameter
drop_reminder. Arti drop_remainder ini adalah kita akan mengambil keseluruhan data tersebut
dan dimasukkan ke dalam batch dengan ukuran tiap batch adalah 32. Apabila data tersebut tidak
habis dibagi kedalam batch dan memiliki sisa data yang tidak mencapai jumlah 32, maka sisa data
tersebut akan dibuang oleh tensorflow.
Setelah ini, kita akan perhatikan bagaimana fungsi dari tensorflow menyatakan model yang
ada didalamnya. Perhatikan sintaks berikut ini.

183
 Kita dapat melihat bahwa pada model tensorflow, dengan menggunakan fungsi layers, kita
dapat melihat urutan tensor didalamnya. Dengan ini, kita dapat dengan mudah memisahkan layer
untuk discriminator dan layer untuk generator. Hal ini akan berguna saat kita melakukan iterasi
untuk proses pelatihan model kita nantinya. Setelah kita jalankan sintaks tersebut, kita akan
melakukan iterasi untuk melatih model kita. Perhatikan sintaks berikut ini.

Kita akan memisahkan generator dan discriminator dari GAN.layers yang telah kita
compile. Kita akan melatih model kita hanya dengan 1 episode saja. Hal pertama yang akan kita
lakukan adalah dengan melatih discriminator. Kita akan menciptakan sebuah noise secara acak
dengan variabel noise dan membuat noise tersebut menjadi sebuah gambar dengan generator(), dan
memasukan gambar tersebut dalam gen_images.

184
 Kita akan menggabungkan kedua gambar tersebut, antara gambar “palsu” yang dihasilkan
oleh generator dan gambar asli dengan menggunakan tf.concat(). Kita juga akan membuat sebuah
variabel y1 yang memberikan label kepada seluruh data gabungan tersebut. Perhatikan bahwa
[0.0]*batch_size pada Python akan menghasilkan hal seperti berikut ini :

Apabila kita menjumlahkannya dengan [1.0]*batch_size, maka kita akan memiliki list
berikut ini.

Dengan ini, variabel y1 akan memuat nilai klasifikasi antara seluruh gambar yang kita
gabungkan pada variabel X_fake_vs_real tersebut. Nilai 0 akan menandakan gambar “palsu”
sedangkan nilai 1 akan menandakan gambar asli. Kita kemudian akan mengaktifkan kembali
discriminator kita dengan menuliskan discriminator.trainable = True, lalu kita akan melatih
discriminator menggunakan data X_fake_vs_real dan y1 yang kita buat barusan. Setelah ini, kita
akan melatih generator kita. Kita akan membuat gambar menggunakan noise. Ingat pada bagian
teori mengenai GAN, bahwa kita akan memberikan seluruh label 1 kepada data generator tersebut,
agar model GAN tersebut seakan “percaya” bahwa data yang dihasilkan generator merupakan data
yang “asli”, sedangkan pada kenyataannya merupakan gambar “palsu” yang kita buat. Agar
discriminator tidak terpengaruh setelah melakukan proses pelatihan pada data X_fake_vs_real, kita
akan mematikan kembali discriminator kita dengan menuliskan discriminator.trainable = False.
Terakhir, kita akan melatih data “asli” dari generator tersebut dengan keseluruhan model kita. Kita
akan mengeluarkan hasil pencatatan untuk tiap 100 batch yang dilewati, dan karena kita hanya
melatih 1 episode saja, maka hanya akan ada 1 output yang ditampilkan (total batch ada 185 batch).
Perhatikan output dari proses pelatihan tersebut berikut ini.

185
 Untuk mendapatkan gambaran, bagaimana gambar noise tersebut terbentuk, kita dapat
mencoba untuk menampilkan sintaks pembentukan gambar noise yang digunakan untuk input
generator. Perhatikan sintaks berikut.

Untuk mendapatkan hasil gambar yang dihasilkan oleh generator, maka kita akan mencoba
untuk memvisualisasikan gambar tersebut. Perhatikan contoh sintaks berikut.

186
 Dengan melatih model GAN tersebut, sekarang kita lihat bahwa generator kita dapat
menghasilkan gambar yang berbentuk seperti angka 0 dengan sebuah input noise. Ingat bahwa noise
yang kita berikan tersebut merupakan sebuah noise acak yang dihasilkan tensorflow. Pada gambar
indeks ke - 0, kita berhasil melihat sebuah gambar yang berbentuk seperti angka 0. Kita akan
mencoba untuk mengecek gambar lainnya di batch tersebut.

Disini kita mengecek gambar lainnya secara acak pada indeks ke - 7 dan mendapati ada hal
yang aneh disini. Kita melihat bahwa data gambar pada indeks ke - 0 dan indeks ke - 7 mirip. Ini
merupakan salah satu kelemahan dari metode GAN ini yang telah kita bahas sebelumnya pada
bagian teori. Ketika kita melakukan proses pelatihan pertama kali dengan menggunakan model
GAN dan iterasi yang kita buat sebelumnya, ketika generator yang kita buat berhasil pertama kali
untuk “membohongi” discriminator kita, maka generator tersebut merasa tidak perlu untuk
menghasilkan sebuah gambar baru atau metode noise baru, karena generator tersebut menganggap
bahwa noise tersebut sudah berhasil “membohongi” discriminator satu kali, dan ketika proses
pelatihan diulang, maka generator akan menggunakan noise yang sama untuk membohongi
discriminator berkali - kali. Hal ini yang menyebabkan seluruh gambar yang dihasilkan oleh
generator akan mirip satu sama lainnya. Untuk menyelesaikan masalah ini, kita akan menggunakan
CNN untuk membantu kita melatih generator ini untuk “memaksa” generator tersebut belajar
menggunakan noise lainnya.

187
 3. Deep Convolutional Generative Adversarial Network (DCGAN)
Deep Convolutional Generative Adversarial Network (DCGAN) merupakan
pengembangan dari metode GAN sebelumnya. Pada pembahasan studi kasus mengenai GAN
sebelumnya, kita memiliki sebuah masalah dimana generator yang kita gunakan menghasilkan
gambar yang mirip satu dengan yang lainnya. Hal ini disebabkan karena ketika generator berhasil
“membohongi” discriminator pertama kali, generator merasa tidak perlu untuk membuat sebuah
noise baru, karena hanya dengan sebuah noise yang dibuat sebelumnya saja berhasil membohongi
discriminator tersebut berkali - kali. Permasalahan ini disebut juga sebagai mode collapse pada
GAN, dimana generator tidak memiliki perkembangan dengan bertambahnya jumlah batch dan
episode yang diberikan. Permasalahan ini sangat umum terjadi ketika kita membuat sebuah model
GAN. Berdasarkan penelitian, hal ini dapat terjadi ketika discriminator memiliki performa yang
jauh lebih baik dibandingkan generator, sehingga efek dari vanishing gradient membuat proses
pelatihan generator menjadi gagal. Dengan performa discriminator yang baik, hal ini membuat
generator tidak memiliki informasi yang cukup untuk digunakan sebagai parameter pelatihan,
sehingga menciptakan mode collapse ini.
Model DCGAN memperbaiki kesalahan yang dibuat oleh generator, dengan cara merubah
data dengan mengubah ukuran data dan memberikan scaling pada X_train. C pada DCGAN
merupakan convolutional, dimana kita menerapkan metode CNN untuk membantu meningkatkan
performa model kita. Untuk meningkatkan performa model juga, kita bisa menambahkan beberapa
activation function, seperti leaky rectified linear unit (leaky relu) dan metode Dropout.
Dengan memperbaiki performa model, terutama discriminator, kita akan mendapatkan nilai
gradien pada discriminator yang lebih baik. Perhatikan bahwa pada GAN, generator tidak pernah
melihat gambar asli. Yang diperhatikan oleh generator merupakan gradien dari discriminator ini.
Dengan membaiknya nilai gradien pada discriminator, informasi yang akan didapatkan oleh
generator juga akan semakin banyak sehingga generator bisa memiliki perkembangan dalam
memproduksi sebuah gambar baru.

188
 Kita akan membuat ulang model tersebut dengan menggunakan DCGAN. Sebagian besar
sintaks yang kita gunakan sama, kita hanya akan menambahkan beberapa baris sintaks untuk
meningkatkan performa. Perhatikan sintaks berikut.

Kita akan mengambil kembali data MNIST dari library tensorflow.keras.datasets, sama
seperti pada GAN sebelumnya. Setelah ini, yang berbeda dari GAN adalah kita akan melakukan
scaling dan reshape terhadap data kita. Hal ini kita lakukan karena kita akan mengubah activation
function yang akan kita gunakan, dengan menggunakan tanh (tangent hyperbolic) pada layer
terakhir. Dengan menggunakan activation function ini, kita perlu mengubah nilai minimum dan
maksimum dari pixel kita menjadi -1 dan 1. Perhatikan sintaks berikut ini.

Setelah ini, kita akan membuat discriminator dan generator kita. Kita akan menambahkan
beberapa layer CNN pada model dan juga memberikan Dropout pada model kita sebanyak 50%,
untuk mematikan setengah neuron yang tidak terpakai. Lalu setelah itu kita juga akan mengubah
activation function pada bagian output dari generator dengan menggunakan tanh. Perhatikan
sintaks berikut ini.

189
 Kita akan meng-import beberapa library layer baru untuk digunakan. Pada pembuatan
discriminator, kita akan menambahkan CNN karena kita tahu sebelumnya bahwa CNN memiliki
performa yang baik pada data berupa gambar. Kita juga memberikan activation function yaitu
Leaky ReLU untuk mendapatkan perubahan nilai pixel negatif dan positif yang berbeda. Kita juga
membuat sebuah fungsi generator baru dimana nilai neuron input merupakan ukuran yang bisa kita
atur, dimana disini kita menggunakan nilai 7 x 7 x 28. Kita juga akan melakukan normalisasi untuk
mengubah nilai tersebut menjadi antara 0 dan 1, lalu kita juga akan melakukan transpose terhadap
hasil yang dihasilkan generator tersebut. Setelah kita membuat fungsi discriminator dan generator,
kita akan menggabungkan keduanya untuk membuat layer GAN kita. Perhatikan sintaks berikut ini.

190
 Kita akan menggabungkan generator dan discriminator kita menjadi GAN. Setelah itu, kita
akan melakukan compile pada discriminator kita dengan menambahkan loss function dan juga
Adam Optimizer, lalu membuat discriminator kita agar tidak melakukan pelatihan. Setelah itu, kita
akan melakukan compile pada model GAN kita dengan loss function binary_crossentropy dan
juga Adam Optimizer.
Kita akan menggunakan parameter yang sama seperti yang kita gunakan pada GAN
sebelumnya. Perhatikan sintaks berikut ini.

Setelah ini, sama seperti yang kita lakukan pada GAN sebelumnya, kita akan melakukan
pelatihan terhadap generator dan discriminator kita. Yang membedakan adalah karena disini kita
menggunakan model yang lebih kompleks dengan menambahkan CNN, beberapa activation
function, dan juga beberapa layer tambahan seperti Dropout dan Normalization, kita akan melatih
model kita untuk jumlah episode yang lebih banyak. Kita akan menggunakan 20 episode. Perhatikan
sintaksnya berikut ini.

191
 Sintaks yang kita gunakan untuk melakukan pelatihan terhadap discriminator dan generator
kita adalah sama. Kita hanya mengubah jumlah episode yang digunakan, dan juga mengubah
rentang pencatatan kita. Sekarang kita akan melakukan pencatatan untuk tiap 20 batch yang
dihasilkan dari proses pelatihan tersebut. Perlu diperhatikan juga bahwa dengan bertambahnya
jumlah episode dan juga layer yang semakin banyak, kita akan memerlukan memori GPU yang
lebih banyak dan waktu pelatihan yang lebih lama. Perhatikan contoh output yang dihasilkan dari
sintaks diatas.

192
 Setelah proses pelatihan selesai, kita akan coba membuat sebuah noise untuk kita masukan
dalam generator nantinya. Perhatikan sintaks berikut.

Setelah ini, kita akan memasukkan nilai noise tersebut dalam generator kita dan mengecek
apakah generator kita dapat menghasilkan gambar yang berbeda. Kita akan coba untuk
menampilkan gambar pada indeks ke - 0.

193
 Perhatikan sekarang generator kita menampilkan bentuk angka 0 yang berbeda dari yang
kita dapatkan pada metode GAN. Sekarang kita akan melakukan pengecekan secara acak untuk
melihat apakah bentuk angka 0 tersebut mirip dengan indeks ke - 0. Kita akan mencoba indeks ke -
7 sama seperti yang kita lakukan pada GAN sebelumnya.

194
 Dengan mengubah metode yang kita gunakan, kita mendapati bahwa bentuk angka 0 pada
indeks ke - 0 dan ke - 7 memiliki bentuk angka 0 yang berbeda. Kita akan mencoba untuk
menampilkan 9 data pertama kita untuk mengecek apakah ada bentuk angka 0 yang mirip. Kita akan
menampilkan data berikut sesuai dengan urutan dimulai dari indeks ke - 0 sampai ke - 9.

Indeks 0 Indeks 1
Indeks 2

Indeks 3 Indeks 4
Indeks 5

Indeks 6 Indeks 7 195

Indeks 8
 Perhatikan sekarang bahwa dengan menggunakan DCGAN, kita mendapatkan bentuk
gambar angka 0 yang lebih bervariasi. Untuk mendapatkan nilai yang lebih baik lagi, kita bisa
menggunakan lebih banyak episode, dan mengubah beberapa parameter yang kita gunakan
sebelumnya pada CNN, maupun jumlah neuron didalamnya.
Setelah ini, kita akan mencoba untuk mempelajari satu lagi metode penggunaan Deep
Learning pada Computer Vision, yaitu YOLO.

4. You Only Look Once (YOLO)

Bagian ini merupakan bagian terakhir yang akan kita pelajari pada Bab Computer Vision
ini. YOLO mungkin merupakan aplikasi dari computer vision yang sering kita temui, apabila kita
mencari referensi menggunakan situs browser. YOLO merupakan singkatan dari You Only Look
Once. Dari namanya, kita mendapatkan gambaran bahwa model yang kita miliki akan melakukan
prediksi langsung ketika model tersebut melihat gambar yang diberikan pada test data. Model ini
hanya perlu melihat test data satu kali, lalu model ini akan langsung memprediksi objek yang ada
didalam gambar tersebut. YOLO akan menggambar sebuah kotak persegi yang menandakan objek
yang ditemukan dalam gambar tersebut. Selain objek tersebut, kita juga akan ditampilkan sebuah
nilai skor. Skor yang memiliki nilai tinggi menandakan bahwa YOLO memiliki tingkat keyakinan
yang tinggi dalam mengklasifikasikan objek tersebut. Berikut ini merupakan contoh hasil output
dari menggunakan metode YOLO ini.

196
 Yang membedakan algoritma YOLO dengan yang lainnya adalah kita perhatikan bahwa
beberapa model yang kita buat sebelumnya membutuhkan sebuah classifier untuk membuat sebuah
detector. YOLO berbeda karena hanya menggunakan 1 neural network saja untuk keseluruhan
gambar. Network ini akan membagi gambar menjadi beberapa area dan memprediksi gambar yang
diinginkan dan juga probabilitasnya untuk tiap area. Probabilitas area ini ditentukan berdasarkan
pembobotan yang diberikan.

Teori
Algoritma YOLO menggunakan neural network yang diterapkan pada gambar dengan
membagi gambar tersebut menjadi beberapa bagian yang bisa kita sebut grid, yaitu kotak - kotak
tertentu. Fungsi kotak ini adalah untuk menjadi ruang gambar yang nantinya akan diberikan nilai
prediksi bounding box. Untuk melihat seperti apa bounding box dari sebuah gambar, perhatikan
gambar berikut ini.

Pada contoh diatas, kita memiliki sebuah bounding box yang melakukan prediksi terhadap
tiga objek, yaitu gambar anjing, sepeda, dan mobil truk. Untuk dapat membuat bounding box
tersebut, dilakukan sebuah proses konvolusi dari gambar input yang diberikan, sehingga kita
mendapatkan ukuran bounding box S x S X (B x 5 + C) dimana S adalah ukuran pixel gambar,
sedangkan B adalah jumlah bounding box dan C adalah banyaknya kelas.
197
 Nilai B dikalikan 5 karena sebuah bounding box memiliki 5 komponen didalamnya, yaitu :
koordinat X, koordinat y, lebar, tinggi, dan confidence score (untuk menentukan nilai probabilitas
dari bounding box tersebut). Perlu diperhatikan bahwa semua nilai pada bounding box akan
dilakukan normalisasi sehingga nilainya hanya berkisar antara 0 dan 1. Sebagai ilustrasi mengenai
bagaimana YOLO dapat bekerja dapat kita lihat pada gambar berikut ini.

YOLO akan memberikan grid pada gambar sesuai ukuran input. Setelah itu, YOLO akan
mulai untuk membuat bounding box dan juga menghitung nilai confidence score pada gambar
tersebut, untuk melakukan prediksi. Pada saat yang sama juga, YOLO akan mencoba untuk
melakukan klasifikasi terhadap gambar input tersebut, untuk menentukan tiap grid akan masuk pada
kelas klasifikasi yang mana. Pada tahap akhir, kita dapat menemukan bounding box untuk tiap objek
pada gambar, sesuai dengan hasil bounding box dan juga prediksi kelas yang dilakukan oleh YOLO.
Seperti yang telah dijelaskan, untuk YOLO ini dapat bekerja kita hanya menggunakan 1
neural network yang terdiri dari 24 convolutional layers dan 2 fully connected layers. Convolutional
layers ini digunakan untuk mengekstrak fitur pada gambar input, sedangkan fully connected layer
ini digunakan untuk menentukan probabilitas klasifikasi dan koordinat dari klasifikasi tersebut.
Gambar dari arsitektur neural network yang digunakan dapat kita lihat berikut ini :

198
 Dengan cara kerja YOLO yang demikian, kita dapat melihat beberapa kelebihan dari YOLO.
Kelebihan dari YOLO ini sendiri memungkinkan kita untuk melakukan pengenalan objek secara
real-time. Kita juga melihat bahwa model yang digunakan tidaklah kompleks dan tidak dibutuhkan
pipeline sekompleks beberapa model lainnya. Dengan menggunakan objek yang sudah
tergeneralisasi, maka YOLO ini juga mudah untuk diterapkan pada gambar input baru. Namun
walaupun memiliki beberapa kelebihan, YOLO juga memiliki kekurangan seperti sulitnya untuk
mendeteksi objek dengan tepat, terutama untuk objek yang memiliki ukuran sangat kecil.

Studi Kasus - Menggunakan YOLO dengan COCO

Pada studi kasus ini, kita akan mencoba untuk membuat sintaks untuk mendeteksi objek
dengan menggunakan YOLO. Referensi yang digunakan untuk percobaan YOLO ini ada pada
halaman Github berikut. Untuk melakukan percobaan ini, kita perlu mendownload dan
memindahkan seluruh komponen pada Google Drive ini dalam sebuah folder Google Drive.
Apabila kita sudah mendownload seluruh file pada Google Drive, kita akan mendapati isi Google
Drive tersebut seperti berikut ini.

199
 Dalam Google Drive ini, kita akan melihat sebuah python file yaitu yolo_model.py. File ini
merupakan sebuah library yang berisikan model YOLO versi 3 yang akan kita gunakan. Perhatikan
bahwa ketika kita buka file ini, kita perlu mengganti lokasi dari file weight yang merupakan
pembobotan YOLO yang sudah dilatih sebelumya.

File weight tersebut merupakan sebuah file dengan extension h5, yang kita simpan dalam
folder data, bernama yolo.h5. File ini yang akan berisi pembobotan dan sudah dilakukan proses
pelatihan sebelumnya. Apabila kita tidak membuat hal ini, memori yang diperlukan untuk proses
pelatihan akan sangat lama, dikarenakan model tersebut perlu mengetahui jenis - jenis klasifikasi
yang ada.

200
 Dalam folder data tersebut juga berisi sebuah .txt file yang berisi seluruh klasifikasi yang
ada pada COCO. COCO (Common Object in Context) merupakan sebuah website yang berisi
kumpulan objek yang dikumpulkan, ditujukan untuk membantu kita melakukan image processing
dan object detection. Klasifikasi tersebut telah kita simpan dalam .txt file tersebut. Dalam folder
tersebut kita juga memiliki gambar yang nantinya akan kita ujikan dengan YOLO. Gambar tersebut
diambil dari referensi berikut ini.
Setelah semua file telah siap, kita akan membuat sintaks kita dengan menggunakan Google
Colab. Pertama, kita akan memasukkan seluruh library yang akan digunakan. Perhatikan disini kita
menggunakan sebuah library yang belum dikenal oleh Google Colab sebelumnya, yaitu
yolo_model.py. File ini tidak bisa ditambahkan dari pip (package installer). Oleh karena itu, kita
akan menggunakan sys untuk memasukkan file ini secara manual. Perhatikan sintaksnya berikut ini.

Kita menggunakan sys untuk menambahkan jalur file agar Google Colab secara default
memiliki akses pada jalur tersebut. Disini kita akan memberikan Google Colab akses kepada folder
YOLO yang kita buat sebelumnya. Dengan folder tersebut dapat diakses oleh Google Colab kita,
maka kita dapat melakukan import library yolo_model.py kedalam Google Colab kita. Perhatikan
sintaksnya berikut ini.

201
 Setelah ini, kita akan membuat beberapa fungsi untuk melakukan YOLO dan memproses
gambar. Fungsi pertama yang akan kita bikin adalah fungsi yang digunakan untuk merubah gambar
input agar menjadi sesuai dengan format yang kita inginkan. Perhatikan sintaksnya berikut ini.

Fungsi tersebut akan merubah ukuran gambar menjadi ukuran 416x416. Selain itu, fungsi
tersebut juga melakukan normalisasi dengan membagi seluruh nilai pixel dengan nilai 255. Kita juga
memberikan np.expand_dims untuk menambahkan dimensi dari gambar tersebut.
Kita akan memanggil fungsi kedua yaitu fungsi yang digunakan untuk membaca klasifikasi
dari COCO. Perhatikan sintaksnya berikut ini.

Fungsi tersebut akan menciptakan sebuah list yang berisikan klasifikasi pada file COCO
yang kita simpan. Apabila kita buka .txt file yang kita simpan sebelumnya pada folder data, kita
akan mendapati bentuknya seperti ini.

202
 Fungsi ketiga yang akan kita buat adalah fungsi untuk menggambarkan persegi dan juga teks
yang digunakan untuk klasifikasi YOLO. Perhatikan fungsinya berikut ini.

Keseluruhan isi dari fungsi tersebut berisikan metode untuk membuat sebuah persegi,
dengan menyatakan lokasi top, left, right, dan bottom dari persegi tersebut. Selain itu, kita juga
menampilkan text yang akan digunakan untuk menampilkan klasifikasi, beserta dengan nilai skor
probabilitas yang dihasilkan.
Setelah kita membuat fungsi untuk menampilkan kotak tersebut, terakhir kita akan membuat
lagi sebuah fungsi yang digunakan untuk mendeteksi gambar. Perhatikan penulisan sintaksnya
berikut ini.

203
 Fungsi tersebut digunakan untuk melakukan prediksi oleh YOLO terhadap gambar yang kita
berikan. Kita akan mencatat lama waktu prediksi tersebut, dan juga menampilkan persegi dan
klasifikasi menggunakan fungsi draw() yang kita buat sebelumnya.
Setelah semua fungsi ini terbentuk dan tidak memiliki error, maka saatnya kita akan melatih
model YOLO kita. Perhatikan sintaksnya berikut ini.

Kita akan memanggil fungsi YOLO kita, lalu memasukkan parameter 0,6 dan 0,5
kedalamnya. Kedua parameter ini dapat kita lihat pada library YOLO yang kita ambil sebelumnya.

Nilai 0,6 merupakan sebuah threshold untuk object dan 0,5 merupakan nilai threshold untuk
kotak yang digambar. Setelah itu, kita juga akan menuliskan lokasi file untuk kelas COCO kita, lalu
kita akan memasukkan file tersebut pada fungsi get_classes() yang kita buat sebelumnya.
Setelah ini, kita akan mencoba untuk melakukan prediksi terhadap gambar. Kita akan
memanggil fungsi cv2_imshow() yang kita biasa gunakan untuk menampilkan sebuah gambar. Lalu
kita juga akan memanggil fungsi detect_image() yang kita buat sebelumnya untuk mendeteksi
objek pada gambar tersebut. Perhatikan sintaksnya berikut ini.

204
 Ketika kita menampilkan gambar tersebut dengan menggunakan cv2_imshow(), yang
pertama kali kita dapatkan adalah informasi mengenai hasil prediksi yang dilakukan oleh YOLO,
sesuai dengan output yang dihasilkan dari fungsi detect_image(). Perhatikan bahwa pada fungsi
detect_image() sebelumnya, kita membuat sebuah prediksi. Nilai tersebut akan menjadi sebuah
input bagi fungsi draw(), dimana pada fungsi draw() ini kita akan menampilkan seluruh hasil
kotak, klasifikasi, dan prediksi kita. Maka kita akan mendapatkan output seperti berikut ini.

205
 Perhatikan bahwa pada gambar tersebut, kita memiliki 4 orang dan juga 1 mobil. Walaupun
mobil tersebut membelakangi kamera dan hanya sebagian saja, namun model YOLO berhasil
mendeteksi objek tersebut sebagai sebuah mobil dengan probabilitas sebesar 0,95. Kita juga melihat
bahwa pada gambar tersebut, kita memiliki 4 orang, namun karena 2 orang wanita berdekatan dan
keduanya menghadap kesamping, model YOLO kita menganggap keduanya merupakan 1 orang,
dan mengeluarkan nilai prediksi bahwa objek tersebut adalah manusia dengan probabilitas sebesar
1,00. Hal ini berarti YOLO sangat yakin bahwa objek tersebut merupakan manusia.
Berikutnya, YOLO mendeteksi 2 orang pria yang lainnya dengan probabilitas masing -
masing adalah 1,00 dan 0,94. Hal ini berarti pada orang yang pertama, model YOLO berhasil
mengidentifikasi objek tersebut sebagai manusia. Pada orang yang kedua, model YOLO mendeteksi
dengan probabilitas sebesar 0,94 yang menandakan bahwa model 94% yakin bahwa objek tersebut
adalah manusia. Hal ini cukup wajar dengan melihat bahwa pada pria kedua tersebut gambarnya
sedikit blur, sehingga mungkin YOLO sulit untuk mendeteksi objek tersebut dengan sempurna.
Namun kita tetap memiliki nilai probabilitas yang cukup tinggi yaitu 94%.
Sebagai kesimpulan, kita telah berhasil membuat model YOLO tersebut, dan apabila kita
memperhatikan hasil teks yang dihasilkan sebelum kita memunculkan gambar tersebut, teks tersebut
berisikan informasi probabilitas yang terbentuk, dan juga lamanya model berjalan. Kita perhatikan
bahwa untuk melakukan prediksi, YOLO membutuhkan waktu 7,10 detik. Setelah itu kita akan
ditampilkan nilai klasifikasi dan juga skor probabilitasnya, dan juga lokasi dan ukuran dari kotak
tersebut. Hal ini terbukti bahwa YOLO bekerja jauh lebih cepat dibandingkan dengan model CNN
yang sebelumnya telah kita coba dan buat. Kita dapat bereksperimen dengan mencoba
menggunakan gambar lainnya dan melihat apakah model YOLO ini akurat. Kita juga dapat
mengecek dan mencoba untuk mengubah beberapa parameter yang ada pada yolo_model.py apabila
kita ingin bereksperimen lebih lanjut mengenai YOLO ini.

206
 Kesimpulan
Computer Vision sendiri merupakan bagian dari pembelajaran mengenai Artificial Intelligence itu
sendiri. Walaupun data yang kita oleh berupa gambar visual, namun karena data visual pada gambar digital
terbentuk dari beberapa array dan angka, maka kita bisa mengolah data tersebut layaknya seperti kita
mengolah data matematis. Banyak metode dan cara yang digunakan untuk memperbaiki performa sebuah
gambar, agar gambar tersebut lebih jelas terlihat atau semakin membaik. Dengan menggunakan image
processing yang merupakan salah satu cabang pembelajaran dari Computer Vision, kita dapat mengekstrak
sebuah informasi visual yang terdapat pada gambar tersebut, agar informasi tersebut dapat diserap maupun
digunakan untuk proses selanjutnya. Berbagai macam teknik digunakan untuk dapat mengekstrak
informasi tersebut, baik dengan menggunakan object detection maupun dengan bantuan metode Deep
Learning.
Computer Vision memiliki dampak yang signifikan terhadap kehidupan manusia sekarang ini,
seperti aplikasi login biometrik, sebagai mata untuk mobil yang bisa menyetir sendiri, CCTV, dan banyak
lainnya. Dengan aplikasinya yang luas dan dapat mendukung kehidupan manusia, maka penting bagi kita
sebagai praktisi di dunia Artificial Intelligence untuk dapat mempelajari penggunaan dari Computer
Vision ini.

207
 Exercise
Cobalah untuk menjawab pertanyaan berikut ini berdasarkan yang telah kamu pelajari
pada bab ini

1. Coba sebutkan 4 macam industri yang dapat menerapkan aplikasi dari Computer
Vision ini, dan sebutkan juga aplikasinya tersebut!

2. Dengan menggunakan Watershed Algorithm, cobalah deteksi gradasi dari

gambar berikut ini!

3. Perhatikan gambar siberian husky berikut ini. Dengan menggunakan model CNN,
coba buat sintaks dan latihlah model tersebut agar bisa mendeteksi gambar
siberian husky tersebut dengan benar, bahwa gambar tersebut diklasifikasikan
sebagai sebuah ‘DOG’!

208