ANALISIS DAN PERANCANGAN SISTEM
3.2 Analisis Sistem
Perancangan sistem pengklasifikasian tumbuhan Angiospermae berdasarkan bentuk tulang daun memiliki beberapa tahap . tahapan pertama merupakan data collecting.
Data yang digunakan adalah citra digital dari daun-daun tumbuhan yang akan digunakan. Penulis akan mengumpulkan beberapa citra digital yang kemungkinan akan digunakan untuk training. Selanjutnya untuk tahap testing, sistem akan berjalan seperti Gambar 3.3. Ketika citra telah diinput, sistem masuk ke tahap preprocessing, yaitu tahap untuk pengolahan data asli sebelum data diolah menggunakan PNN sebagai classifier. Pada tahap ini, citra diubah ukurannya sesuai dengan ketentuan agar lebih mudah diolah dan ukuran datanya tepat. Kemudian, citra akan diubah dari RGB menjadi gray-scale. Setelah itu, untuk mengidentifikasi nama tanaman, masuk ke tahap shape segmentation untuk pengklasifikasian nama tanaman berdasarkan bentuk daun. Dalam proses ini, terdapat tiga tahap. Pertama, citra akan diubah menjadi binary image, kemudian tahap menghilangkan noise menggunakan Gaussian blur.
Terakhir, citra yang telah diubah menjadi gambar biner, diubah menjadi inverse image-nya. Selanjutnya, untuk mengidentifikasi tanaman masuk ke kelompok dikotil atau monokotil, masuk ke tahap vein segmentation untuk mengambil bagian penting yang unik dari citra, yaitu tulang daun. Pertama, dilakukan Canny Edge Detection untuk mendeteksi garis tepi pada citra. Terakhir, binarization yaitu mengubah citra menjadi biner. Kemudian, citra diekstraksi menggunakan fitur GLCM yang terdiri dari contrast, correlation, energy, dissimilarity, ASM, homogeneity, dan entropy. Lalu masuk ke tahap PNN untuk mengklasifikasikan jenis tumbuhan berdasarkan citra yang telah diolah. Kemudian, hasil akan muncul. Adapun untuk memperjelas tahapan penelitian ini dapat dilihat pada Gambar 3.3.
1.439 data latih (80%) 361 data uji (20%)
Gambar 3.3. Arsitektur Umum
3.2.1 Pre-processing
Sebelum melakukan segmentasi dan klasifikasi, citra dipersiapkan dengan tahap preprocessing. Preprocessing terdiri dari 2 tahap, yaitu image resize dan RGB to gray-scale image.
3.2.1.1 Image Resize
Beberapa gambar memiliki ukuran citra yang berbeda-beda, karena itu untuk mempermudah sistem bekerja, harus dibuat standar ukuran yang tepat dan citra yang
tidak sesuai dengan standar tersebut akan diubah menjadi seukuran standar. Ukuran standar dalam penelitian ini ialah 224 x 224 pixel.
- Fungsi resize dilakukan menggunakan library OpenCV. CV2.resize merupakan fungsi OpenCV untuk merubah ukuran gambar dengan sintaks
cv2.resize(src,dsize[,dst[,fx[,fy[,interpolation]]]]). Fungsi resize memiliki dua parameter yang wajib dicantumkan, parameter pertama, yaitu souce dari gambar. Parameter keduanya ialah ukuran akhir yang diharapkan, yaitu 224x224. Untuk parameter-parameter lainnya yang tidak wajib dimasukkan ialah fx untuk sumbu horizontal (x), fy untuk sumbu vertikal (y), dan yang terakhir adalah interpolation untuk teknik resize yang digunakan.
- Teknik resize yang digunakan ialah bilinear interpolation, yang dimana merupakan salah satu jenis interpolasi. Billinear interpolation merupakan penulisan kembali atau pembuuatan ulang dengan mengubah nilai dengan nilai terdekat. Billinear interpolation menjadi teknik default untuk fungsi resize, karena itu tidak perlu dicantumkan.
3.2.1.2 Gray-scale Image
Mengubah citra daun yang memilki berbagai macam warna menjadi warna putih, abu-abu, dan hitam dengan menggunakan grayscale. Untuk mengganti RGB menjadi grayscale, bisa diterapkan dengan mengambil seluruh piksel citra, yang selanjutnya mengambil informasi 3 warna dasar, yaitu red, green, dan blue (melalui fungsi warna to RGB), 3 warna ini akan ditambahkan dan dibagi 3 sehingga mendapatkan rata-rata yang kemudian akan digunakan untuk memberi warna pada piksel citra sehingga citra RGB menjadi grayscale. (Santi, 2011).
Citra daun sesudah dilakukan image resize dan sesudah diubah menjadi gray-scale dapat dilihat di Gambar 3.4.
img = cv2.resize(img,(224,224))
Gambar 3.4. Citra daun asli (kiri), citra daun sesudah diubah dilakukan preprocessing (kanan)
Langkah proses gray-scale yang dilakukan di penelitian ini bisa dilihat di bawah ini.
- Membaca citra menggunakan fungsi imread dari library OpenCV.
CV2.imread memiliki sintaks CV2.imread(path,flag). CV2.imread berfungsi untuk membaca gambar dari path file yang diberikan. Gambar akan diproses tergantung dengan flag yang diberikan. Flag memiliki default 1 yang berarti color, atau gambar berwarna. Nilai flag 0 akan membaca gambar menjadi gray-scale seperti cara di atas, dan nilai flag -1 yaitu untuk membaca gambar beserta alpha channelnya. Jika citra merupakan gambar berwarna, maka nilai keabuan tiap piksel akan dihitung dengan mengambil rata-rata nilai warna dan membacanya dengan array.
Berikut adalah penjelasan implementasi proses gray-scale image dengan representasi data berukuran 3x3 seperi Gambar 3.5.
Gambar 3.5. Citra daun sebelum melalui proses gray-scale
img = cv2.imread(filename[3],0)
Gambar 3.5. merupakan potongan citra daun berukuran 3x3 dengan RGB nilai masing-masing pixel-nya sebagai berikut:
P1 = 47, 92, 53 P2 = 10, 115, 60 P3 = 22, 85, 55 P4 = 83, 158, 158 P5 = 55, 131, 83 P6 = 20, 122, 73 P7 = 64, 119, 103 P8 = 66, 157, 121 P9 = 4, 79, 38
Untuk mengubah citra RGB menjadi citra gray-scale dilakukan dengan mencari nilai ratarata dari total nilai RGB. Hasil dari pemanggilan library Open CV dengan nama fungsi yaitu imread dengan parameter 0 untuk membaca citra dan mengubah citra menjadi gray-scale image.
P1 = (47+92+53) = 192/3 → 64 P2 = (10+115+60) = 186/3 → 62 P3 = (22+85+55) = 162/3 → 54 P4 = (83+158+158) = 399/3 → 133 P5 = (55+131+83) = 270/3 → 90 P6 = (20+122+73) = 216/3 → 72 P7 = (64+119+103) = 288/3 → 96 P8 = (66+157+121) = 345/3 → 115 P9 = (4+79+38) = 120/3 → 40
Gambar 3.6. Citra daun setelah melalui proses gray-scale
Gambar 3.6. merupakan hasil dari implementasi proses gray-scale image terhadap representasi data berukuran 3x3.
3.2.2 Shape Segmentation
Tahap shape segmentation dilakukan untuk menentukan nama tumbuhan berdasarkan garis tepi daun. Tahap shape segmentation terdiri dari tiga tahapan, yaitu converting to binary image, Gaussian blur, dan transform to inverse image.
3.2.3.1 Binary Image
Mengkonversi citra ke binary image memiliki proses yang mirip dengan mengkonversi citra ke gray-scale, perbedaannya ialah warna rata-rata akan dibagi menjadi 2 kelompok, dengan ketentuan jika intensitas warna ialah 0–255, diambil mediannya, yaitu 127. Jika intensitas warna lebih rendah dari 127 maka warna akan menjadi hitam dan jika intensitas warna lebih tinggi dari 127 warna akan menjadi putih (Santi, 2011). Citra daun sesudah dilakukan preprocessing dan sesudah diubah menjadi binary image bisa dilihat di Gambar 3.7.
Gambar 3.7. Citra daun sesudah dilakukan preprocessing (kiri), citra daun sesudah diubah menjadi binary image (kanan)
Mengubah grayscale menjadi binary image dilakukan dengan cara mencari batas dari nilai threshold. Jika nilai intensitas citra ≥ nilai threshold, maka citra akan diubah menjadi bernilai 1 dan berwarna putih. Sebaliknya, jika nilai intensitas citra <
nilai threshold, maka citra akan diubah menjadi bernilai 0 dan berwarna hitam.
Gambar 3.8. Citra daun 3x3 sebelum diubah menjadi binary image
Berikut adalah nilai grayscale dari citra pada gambar 3.8.
P1 = 64, 64, 64 P2 = 62, 62, 62 P3 = 54, 54, 54 P4 = 133, 133, 133 P5 = 90, 90, 90 P6 = 72, 72, 72 P7 = 96, 96, 96 P8 = 115, 115, 115 P9 = 40, 40, 40
Dengan nilai threshold diambil dari nilai tengah 0-255, yaitu 127. Jika nilai intensitas citra ≥ 127, maka akan diubah menjadi putih, sebaliknya, jika nilai intensitas < 127, maka akan diubah menjadi hitam. Lebih jelasnya akan dijabarkan di bawah ini.
P1 = 64 < 127, 1 atau warna hitam P2 = 62 < 127, 1 atau warna hitam P3 = 54 < 127, 1 atau warna hitam P4 = 133 ≥ 127, 0 atau warna putih P5 = 90 < 127, 1 atau warna hitam
P6 = 72 < 127, 1 atau warna hitam P7 = 96 < 127, 1 atau warna hitam P8 = 115 < 127, 1 atau warna hitam P9 = 40 < 127, 1 atau warna hitam
Sehingga, citra 3x3 yang sudah diolah dapat dilihat di gambar 3.9.
Gambar 3.9. Citra daun 3x3 sesudah diubah menjadi binary image
3.2.3.2 Gaussian Blur
Gaussian blur dinamai berdasarkan nama ahli matematika dan ilmuan, yaitu Carl Fredrich Gauss. Gaussian blur termasuk low-pass filter.Tahap Gaussian blur (penghalusan Gaussian) berfungsi untuk menghaluskan gambar, hal ini memungkinkan untuk mengurangi noise dan detail gambar sehingga mempermudah proses pengenalan gambar. Citra daun sesudah diubah menjadi binary image dan sesudah diubah dilakukan proses Gaussian blur dapat dilihat di Gambar 3.8.
Gambar 3.10. Citra daun sesudah diubah menjadi binary image (kiri), citra daun sesudah dilakukan tahap Gaussian blur (kanan)
Untuk menerapkan Gaussian blur, tentukan lokasi entri pada kernel filter.
Setidaknya berukuran 5x5 piksel. Berikut ialah implementasi Gaussian blur pada citra 5x5 dengan 𝜎2 = 1.
Gambar 3.11. Lokasi entri kernel filter pada citra 5x5
𝐺(0,0) = 𝑒−0= 1
𝐺(1,0) = 𝐺(0,1) = 𝐺(−1,0) = 𝐺(0, −1) = 𝑒−12 = 0,6065 𝐺(1,1) = 𝐺(1, −1) = 𝐺(−1,1) = 𝐺(−1, −1) = 𝑒−1 = 0,3679 𝐺(2,1) = 𝐺(1,2) = 𝐺(−2,1) = 𝐺(−2, −1) = 𝑒−52 = 0,0821 𝐺(2,0) = 𝐺(0,2) = 𝐺(0, −2) = 𝐺(−2,0) = 𝑒−2 = 0,1353 𝐺(2,2) = 𝐺(−2, −2) = 𝐺(−2,2) = 𝐺(2, −2) = 𝑒−4 = 0,0183
Selanjutnya hasil-hasil tersebut dilakukan perkalian dengan 55 untuk mengubah nilai terkecil menjadi 1. Nilai 55 didapat dari 1/0,0183 yang selanjutnya dibulatkan ke atas. Kemudian dilakukan perkalian nilai 𝐺(𝑥, 𝑦) dengan 55.
Gambar 3.12. Citra yang sudah dikalikan dengan 55
Selanjutnya dilakukan normalisasi sehingga diperoleh filter seperti berikut.
Gambar 3.13. Citra yang telah dinormalisasi
3.2.3.3 Inverse Image
Transform to inverse image merupakan proses membalik warna yang kontras pada citra dengan warna aslinya. Untuk citra yang telah diolah dengan proses-proses di atas, proses inverse image berguna untuk memperjelas garis tepi sehingga bentuk daun terlihat jelas dan dapat mempermudah pengklasifikasian nama tumbuhan. Citra daun sesudah dilakukan proses Gaussian blur dan sesudah diubah menjadi inverse image bisa dilihat di Gambar 3.14.
Gambar 3.14. Citra daun sesudah dilakukan tahap Gaussian blur (kiri), citra daun sesudah diubah menjadi inverse image (kanan)
Langkah-langkah proses shape segmentation yang dilakukan di penelitian ini bisa dilihat di bawah ini.
- Langkah pertama yaitu dilakukan proses perubahan citra daun menjadi binary image menggunakan metode threshold untuk mengenali objek.
Digunakan fungsi CV2.threshold dengan parameter pertama adalah gambar
def preprocess_shape(img,th,nkernel):
img = cv2.threshold(img,th,255,cv2.THRESH_BINARY)[1]
img = cv2.GaussianBlur(img,(5,5),0) img = ~img
return img
yang akan diolah, parameter kedua ialah threshold, parameter ketiga ialah nilai maksimal, dan parameter terakhir ialah jenis threshold yang digunakan. Cara kerjanya ialah diambil nilai threshold, yaitu 127, yang diambil dari nilai tengah 0-255. Jika intensitas piksel > 127, maka nilai akan diubah menjadi 255 atau putih, selain itu akan diubah menjadi 0 atau hitam. Menggunakan parameter THRESH_BINARY untuk memisahkan objek menjadi hitam dan background menjadi putih.
- Langkah kedua yaitu proses filter blur dengan Gaussian blur. Metode ini akan mengambil warna tengah dari dua warna berbeda sehingga menciptakan efek lembut pada citra. Fungsi Gaussian blur dilakukan menggunakan library OpenCV. Sintaks yang digunakan ialah
cv2.GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType=BORDER_DEFAULT]]] ). Parameter pertama ialah sumber gambar, parameter kedua ialah ukuran kernel [tinggi, lebar], parameter ketiga ialah sigmaX untuk deviasi standar kernel sepanjang sumbu x (horizontal), selanjutnya ialah dst atau output gambar, parameter selanjutnya ialah sigmaY untuk deviasi standar kernel sepanjang sumbu y (vertikal) yang jika diisi 0 maka akan diambil nilai sigmaX, dan parameter terakhir ialah tipe border yang jika tidak dicantumkan akan dilakukan dengan tipe border default.
- Langkah ketiga yaitu proses membalik warna yang kontras pada citra dengan warna aslinya dengan metode inverse image, sehingga garis tepi daun dan bentuk daun yang sebelumnya terlihat blur jadi terlihat lebih jelas.
3.2.3 Vein Segmentation
Tahap vein segmentation dilakukan untuk menentukan jenis biji tumbuhan tersebut, apakah dikotil atau monokotil berdasarkan tulang daun (vein). Tahap vein segmentation terdiri dari dua tahapan, segmentation, dan binarization.
3.2.3.1 Canny Edge Detection
Canny merupakan sebuah metode edge detection atau pendeteksi tepi yang ditemukan oleh Marr dan Hildreth dan kemudian tahun 1986 dikembangkan oleh John F. Canny.
Metode ini berfungsi untuk mendeteksi garis tepi citra dengan multi-tahap. Garis tepi merupakan sebuah kontras antara permukaan tintaan dan garis pada jalan. Metode ini sudah cukup berumur tapi masih banyak digunakan karena efektif untuk mendeteksi tepi. Metode ini dapat membuat garis-garis tepi daun dan tulang daun terlihat jelas.
Untuk lebih jelasnya citra daun yang sudah dilakukan preprocessing dan citra daun yang sudah dilakukan proses pendeteksi tepi Canny dapat dilihat di Gambar 3.15.
Gambar 3.15. Citra daun sesudah dilakukan preprocessing (kiri), citra daun sesudah dilakukan tahap Canny edge detection (kanan)
Sebagai contoh implementasi Canny edge detection, berikut adalah contoh perhitungan dengan citra yang sudah diubah menjadi matrix 5x5.
Kemudian diterapkan metode Gaussian pada matriks.
Selanjutnya dilakukan seleksi dengan tepian prewit menggunakan matriks
Selanjutnya ialah perhitungan seleksi horizontal yang dilakukan menggunakan matriks 𝑃𝑥 di atas.
𝐺1(𝑥, 𝑦) = |(-1*143)+(-1*114)+(-1*100)+(1*107)+(1*86)|
= |(-57)|
= 57
Untuk perhitungan seleksi vertikal, dilakukan menggunakan matriks 𝑃𝑦 di atas.
𝐺𝑦(𝑥, 𝑦) = |(-1*143)+(-1*129)+(1*107)+(1*100)+(1*86)+(1*86)|
Selanjutnya ialah penentuan arah tepi dengan syarat sebagai berikut:
- Arah tepian menjadi 0 ̊ jika arah tepi adalah 0 ̊ - 22,5 ̊ , 157,5 ̊ , atau 180 ̊ .
3.2.3.2 Binary Image
Mengkonversi citra ke binary image memiliki proses yang mirip dengan mengkonversi citra ke gray-scale, perbedaannya ialah warna rata-rata akan dibagi menjadi 2 kelompok, dengan ketentuan jika intensitas warna ialah 0 – 255, diambil nilai tengahnya, yaitu 127. Jika intensitas warna lebih rendah dari 127 maka warna akan menjadi hitam dan jika intensitas warna lebih tinggi dari 127 warna akan menjadi putih (Santi, 2011). Untuk lebih jelasnya citra daun sesudah dilakukan tahap Canny edge detection dan citra daun yang sudah diubah menjadi binarization dapat dilihat di Gambar 3.16.
Gambar 3.16. Citra daun sesudah dilakukan tahap Canny edge detection (kiri), citra daun sesudah diubah menjadi binary image (kanan)
Langkah-langkah proses vein segmentation yang dilakukan penelitian ini bisa dilihat di bawah ini.
- Langkah pertama yaitu dilakukan proses mendeteksi tepi dengan Canny edge detection. Metode ini dilakukan dengan multi-tahap. Pertama, menghilangkan noise dengan Gaussian blur, kemudian menghitung potensi gradient citra menggunakan algoritma Canny, lalu menghitung arah tepi dan kemudian menghubungkannya, kemudian menghilangkan non-maksimum di sepanjang tepi pada arah tepi dan menghilangkan pixel yang tak dianggap sebagai tepi sehingga diperoleh tepi yang tipis, kemudian dilakukan hysteresis thresholding.
def preprocess_vein(img,th,nkernel,th1,th2):
kernel=np.ones((nkernel,nkernel),np.uint8) img = cv2.Canny(img,th1,th2)
img = cv2.threshold(img,th,255,cv2.THRESH_BINARY)[1]
return img
- Fungsi canny dilakukan dengan menggunakan library OpenCV, yaitu dengan sintaks cv2.canny dengan parameter pertama adalah image yang berupa array, parameter kedua ialah threshold 1 dan threshold 2 yang berfungsi sebagai batas atas dan batas bawah pada intensitas gradient. Lalu hasil dari canny tersebut adalah gambar yang sudah dideteksi sudutnya.
- Langkah terakhir yaitu dilakukan proses perubahan citra daun menjadi binary image menggunakan metode threshold untuk mengenali objek.
Digunakan fungsi CV2.threshold dengan parameter pertama adalah gambar yang akan diolah, parameter kedua ialah threshold, parameter ketiga ialah nilai maksimal, dan parameter terakhir ialah jenis threshold yang digunakan. Cara kerjanya ialah diambil nilai threshold, yaitu 127, yang diambil dari nilai tengah 0-255. Jika intensitas piksel > 127, maka nilai akan diubah menjadi 255 atau putih, selain itu akan diubah menjadi 0 atau hitam. Menggunakan parameter THRESH_BINARY untuk memisahkan objek menjadi hitam dan background menjadi putih.
3.2.4 GLCM
Gray Level Co-Occurrence Matrix berguna untuk menganalisis piksel citra untuk mendeteksi tingkat keabuan yang sering terjadi. GLCM juga berfungsi untuk tabulasi tentang frekuensi kombinasi nilai pixel yang muncul pada suatu citra (Xie, 2010).
Ekstraksi ciri dilakukan berdasarkan parameter contrast, dissimilarity, homogeneity, angular second moment (ASM), energy, correlation, dan entropy.
Langkah-langkah untuk melakukan ekstraksi fitur GLCM terdapat empat tahap, yaitu:
1. Mencari nilai matriks kookurensi dengan cara menghitung jumlah pasangan piksel dengan intensitas yang sama dan memasukkan nilainya ke dalam area kerja matriks GLCM. Dalam menentukan pasangan piksel, keseluruhan nilai ada matriks grayscale ditempatkan matriks kookurensi dengan merujuk pada ketentuan graylevel mode warna grayscale (8-bit image) berupa 28=256.
Gambar 3.17. Matriks kookurensi
2. Mencari nilai matriks simetris dengan cara menjumlahkan matriks kookurensi dengan matriks transposenya.
Gambar 3.18. Perhitungan matriks simetris
3. Normalisasi nilai matriks simetris untuk memperoleh suatu nilai dalam bentuk probabilitas.
Gambar 3.19. Matriks normalisasi
4. Menghitung nilai feature vector dengan cara menghitung ciri statistik orde dua. Berikut cara menghitung fitur-fitur GLCM.
- Menghitung fitur contrast
Contrast = 0)²)+ 1)²)+ (0.01*(0-2)²)+ 3)²)+ (0*(0-4)²)+ (0*(0-5)²)+ (0*(0-6)²)+ (0*(0-7)²)+ (0*(0-8)²)+ (0*(0-9)²)+
(0.01*(1-0)²)+ 1)²)+ 2)²)+ 2)²)+ 3)²)+ (0*(1-4)²)+ (0*(1-5)²)+ (0*(1-6)²)+ (0.01*(1-7)²)+ (0*(1-8)²)+ (0*(1-9)²)+
(0.01*(2-0)²)+ (0*(2-1)²)+ (0*(2-2)²)+ (0*(2-3)²)+ (0*(2-4)²)+
(0.01*(2-5)²)+ (0*(2-6)²)+ (0*(2-7)²)+ (0*(2-8)²)+ (0*(2-9)²)+ (0*(3-0)²)+ (0*(3-1)²)+ (0*(3-2)²)+ (0*(3-3)²)+ (0*(3-4)²)+ (0.01*(3-5)²)+
(0*(3-6)²)+ (0*(3-7)²)+ (0*(3-8)²)+ (0*(3-9)²)+ (0*(4-0)²)+ (0*(4-1)²)+
(0*(4-2)²)+ (0*(4-3)²)+ (0*(4-4)²)+ (0*(4-5)²)+ (0*(4-6)²)+ (0.01*(4-7)²)+ (0*(4-8)²)+ (0.01*(4-9)²)+ (0*(5-0)²)+ (0*(5-1)²)+ (0.01*(5-2)²)+
(0*(5-3)²)+ (0*(5-4)²)+ (0.07*(5-5)²)+ (0.08*(5-6)²)+ (0.02*(5-7)²)+
(0*(5-8)²)+ (0.04*(5-9)²)+ 0)²)+ 1)²)+ 2)²)+ 3)²)+ 4)²)+ (0.07*(6-5)²)+ (0.08*(6-6)²)+ (0.02*(6-7)²)+ (0*(6-8)²)+ (0.04*(6-9)²)+ (0*(7-0)²)+ (0.01*(7-1)²)+ (0*(7-2)²)+ (0*(7-3)²)+
(0.01*(7-4)²)+ (0.02*(7-5)²)+ (0.09*(7-6)²)+ (0.2*(7-7)²)+ (0.06*(7-8)²)+ (0*(7-9)²)+ 0)²)+ 1)²)+ 2)²)+ 3)²)+ 4)²)+ (0.01*(8-5)²)+ 6)²)+ (0.03*(8-7)²)+ (0.06*(8-8)²)+ (0*(8-9)²)+ (0*(9-0)²)+ (0*(9-1)²)+ (0*(9-2)²)+ (0*(9-3)²)+ (0.01*(9-4)²)+
(0.04*(9-5)²)+ (0.01*(9-6)²)+ (0*(9-7)²)+ (0*(9-8)²)+ (0*(9-9)²)
= 3.471545
- Menghitung fitur energy
Energy = (0)²+ (0)²+ (0.01)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+
(0.01)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0.01)²+ (0)²+ (0)²+ (0.01)²+
(0)²+ (0)²+ (0)²+ (0)²+ (0.01)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+
(0)²+ (0)²+ (0.01)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+
(0)²+ (0)²+ (0.01)²+ (0)²+ (0.01)²+ (0)²+ (0)²+ (0.01)²+ (0)²+ (0)²+
(0.07)²+ (0.08)²+ (0.02)²+ (0)²+ (0.04)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+
(0.07)²+ (0.08)²+ (0.02)²+ (0)²+ (0.04)²+ (0)²+ (0.01)²+ (0)²+ (0)²+
(0.01)²+ (0.02)²+ (0.09)²+ (0.2)²+ (0.03)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0)²+
(0)²+ (0)²+ (0)²+ (0.03)²+ (0.06)²+ (0)²+ (0)²+ (0)²+ (0)²+ (0.01)²+
(0.04)²+ (0.01)²+ (0)²+ (0)²+ (0)²
= 0.086787
- Menghitung fitur entropy
Entropy = -(0(log(0))+ (0(log(0))+ (0.01(log(0.01))+ (0(log(0))+
(0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0.01(log(0.01))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0(log(0))+ (0.01(log(0.01))+ (0(log(0))+ (0(log(0))+
(0.01(log(0.01))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0.01(log(0.01))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0.01(log(0.01))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0.01(log(0.01))+ (0(log(0))+ (0.01(log(0.01))+ (0(log(0))+
(0(log(0))+ (0.01(log(0.01))+ (0(log(0))+ (0(log(0))+ (0.07(log(0.07))+
(0.08(log(0.08))+ (0.02(log(0.02))+ (0(log(0))+ (0.04(log(0.04))+
(0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0.7(log(0.07))+ (0.08(log(0.08))+ (0.02(log(0.02))+ (0(log(0))+
(0.04(log(0.04))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0.07(log(0.07))+ (0.08(log(0.08))+ (0.02(log(0.02))+
(0(log(0))+ (0.04(log(0.04))+ (0(log(0))+ (0.01(log(0.01))+ (0(log(0))+
(0(log(0))+ (0.01(log(0.01))+ (0.02(log(0.02))+ (0.09(log(0.09))+
(0.02(log(0.02))+ (0.03(log(0.03))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0.03(log(0.03))+ (0.06(log(0.06))+ (0(log(0))+ (0(log(0))+ (0(log(0))+
(0(log(0))+ (0(log(0))+ (0.01(log(0.01))+ (0.04(log(0.04))+
(0.01(log(0.01))+ (0(log(0))+ (0(log(0))+ (0(log(0))
= 1.219727
Hasil perhitungan GLCM yang telah melalui tahap shape segmentation dapat dilihat di tabel 3.3.
Tabel 3.3 Hasil GLCM Shape
No
Shape
Y1 Y2
Contrast Energy Homo-geneity
6.320 Dikotil Alpukat
Hasil perhitungan GLCM yang telah melalui tahap vein segmentation dapat dilihat di tabel 3.4.
Tabel 3.4 Hasil GLCM Vein
No
Vein
Y1 Y2
Contrast Energy Homo-geneity
Langkah-langkah proses feature extraction menggunakan 6 parameter GLCM dapat dilihat di bawah ini.
- Langkah pertama, masukkan parameter-parameter GLCM yang akan digunakan. Penelitian ini menggunakan 6 parameter, yaitu contrast, energy, homogeneity, correlation, dissimilarity, dan ASM.
- Langkah kedua yaitu memasukkan nilai-nilai pada GLCM seperti jarak (distances), sudut (angles), dan levels. Sesuai dengan di atas, penelitian ini memilih jarak=1, sudut=0, dan levels=256.
- Langkah ketiga yaitu entropi Shannon sebagai pengukur informasi citra banyak digunakan dalam aplikasi pemrosesan citra. Pengukuran ini memerlukan perkiraan fungsi kepadatan probabilitas gambar dimensi tinggi yang menimbulkan batasan dari sudut pandang praktis.
3.2.5 PNN
Probabilistic Neural Network (PNN) digunakan sebagai pengklasifikasi setelah dilakukan feature extraction menggunakan GLCM pada citra. PNN memiliki 4 buah layer, yaitu lapisan input, pola, penjumlahan, dan output/keputusan.
PNN memiliki 4 lapisan, yaitu lapisan input, pola, penjumlahan, dan output/keputusan.
3.2.5.1 Lapisan Input (Input Layer)
Pada input layer, dimasukkan citra daun tumbuhan angiospermae yang telah dilakukan proses feature extraction dengan 7 fitur GLCM, yaitu contrast, energy, homogeneity, correlation, dissimilarity, ASM, dan entropy, dari shape segmentation dan vein segmentation yang telah digabungkan. Kemudian data tersebut akan menjadi data untuk proses learning (pembelajaran) pada algoritma yang dibangun untuk klasifikasi jenis tumbuhan
def extract_features(img):
glcm_type = ["contrast",'energy','homogeneity','correlation','d issimilarity','ASM']
glcm = greycomatrix(img, [1], [0], 256, symmetric=True, normed=
True)
x = [greycoprops(glcm, i)[0, 0] for i in glcm_type]
x.append(measure.shannon_entropy(img)) return x
3.2.5.2 Lapisan Pola (Pattern Layer)
Pada pattern layer, dilakukan perhitungan jarak (distance) antara vektor input dengan vektor bobot training yang dipresentasikan oleh neuron dengan cara perkalian titik antara vektor x dengan vektor bobot pelatihan, yang kemudian hasilnya dimasukkan ke dalam fungsi Probability Density Function (PDF) yang umum digunakan pada pattern layer, yaitu Gaussian. Fungsi Gaussian ditunjukkan dalam Persamaan 2.1
Dengan konstanta σ (std) tertentu (berdasarkan kodingan di penulisan, std = 1).
Jika input bernilai besar, maka std juga harus bernilai besar. Nilai std yang kecil akan menyebabkan prediksi yang buruk. Langkah-langkah proses pattern layer pada PNN dapat dilihat di bawah ini.
- Langkah pertama ialah training dataset dengan input array dataset dan std.
- Langkah kedua ialah membuat variabel baru berisi nol untuk menyimpan hasil akhir menggunakan fungsi zeros, kemudian dilakukan perhitungan std dengan akan kuadrat dari 2 x nilai konstanta pi.
- Langkah ketiga dilakukan membuat sebuah array mengulang sejumlah array dengan mengulang sejumlah kali yang diberikan repetisi menggunakan tile. Digunakan fungsi tile untuk membuat baris sebanyak data sampel. Kemudian perhitungan selisih nilai data training dengan inputs. Kemudian menghitung total jarak dengan fungsi inner1d, yaitu hasil kali dalam vektor biasa untuk larik 1-D.
def pattern_layer(train_data, X, std):
n_train_samples = train_data.shape[0]
n_samples = X.shape[0]
results_pattern = np.zeros((n_train_samples, n_samples)) variance = std ** 2
const = std * math.sqrt(2 * math.pi)
for i, input_row in enumerate(X):
inputs = np.tile(input_row, (n_train_samples, 1)) class_difference = (train_data - inputs)
total_distance = inner1d(class_difference, class_difference)
results_pattern [:, i] = np.exp(-total_distance / variance) / const
return results_pattern
- Langkah terakhir ialah perhitungan results_pattern dengan np.exp(-total_distance / variance) / const yang telah dihitung sebelumnya.
3.2.5.3 Lapisan Penjumlahan (Summation Layer)
Pada summation layer, dilakukan penjumlahan dari tiap kelas yang telah dihasilkan pattern layer, kemudian ditampung di neuron-neuron, dimana setiap kelas memiliki satu neuron. Persamaan summation layer dapat dilihat di Persamaan 2.2.
Langkah-langkah proses summation layer pada PNN dapat dilihat di bawah ini.
- Langkah pertama ialah membuat fungsi summation_layer dengan kelas classes yang berisi nilai unik, n_classes berisi ukuran classes, dan n_samples berisi X_train.shape.
- Langkah kedua ialah menghitung class_ratios dengan membuat variabel baru berisi nol untuk menyimpan hasil n_classes menggunakan fungsi zeros. Kemudian membuat matrix berdasarkan hasil n_classes dan n_samples.
- Langkah ketiga ialah pembuatan matrix dari penjumlahan class_val positions yang telah dilakukan ravel.
def summation_layer(results_pattern, X_train, y_train):
classes = np.unique(y_train) n_classes = classes.size n_samples = X_train.shape[0]
class_ratios = np.zeros(n_classes) row_comb_matrix = np.zeros(
(n_classes, n_samples))
for i, class_name in enumerate(classes):
class_name = classes[i]
class_val_positions = (y_train == class_name)
row_comb_matrix[i, class_val_positions.ravel()] = 1 class_ratios[i] = np.sum(class_val_positions)
results_summation = np.dot(row_comb_matrix, results_pattern) / class_ratios
- Langkah terakhir ialah perhitungan results_summation dengan membuat titik dari row_comb_matrix pada summation layer dan results_pattern pada pattern layer. Hasil tersebut kemudian dibagi dengan class_ratios.
3.2.5.4 Lapisan Output / Keputusan (Decision Layer)
Pada decision layer, dihasilkan sebuah vektor dengan panjang M elemen, dimana M merupakan banyaknya kelas. Vektor input x akan diklasifikasi ke dalam kelas M, jika nilai p(x) indek ke M pada vektor output merupakan nilai terbesar jika dibandingkan dengan elemen lainnya.
Langkah-langkah proses decision / output layer pada PNN dapat dilihat di bawah ini.
- Langkah pertama ialah memasukkan fungsi concantenate pada results_summation untuk menggabungkan urutan array di sepanjang axis 1.
- Langkah kedua ialah menentukan results_output dengan mencari nilai paling maksimal dari array.
Berikut implementasi perhitungan PNN dengan representasi data yang sedikit menggunakan data input pada Tabel 3.3 yaitu data 1, 2 dan 3, dengan pembagian data 1 dan data 2 merupakan data training dan data 3 merupakan data testing yang tidak berikan label untuk dilakukan pengujian dalam menentukan klasifikasi jenis daun.
Data yang digunakan untuk implementasi dapat dilihat pada Tabel 3.5.
Tabel 3.5 Data input implementasi PNN
No
Shape
Y1 Y2
Contrast Energy Homo-geneity
output = np.concatenate(results_summation, axis=1) results_output = self.classes[output.argmax(axis=0)]
return results_output
3 7.948.9
Pada tahap klasifikasi menggunakan metode PNN. Data input yang diberikan
Pada tahap klasifikasi menggunakan metode PNN. Data input yang diberikan