Kompetisi Deep Learning

Tidak hanya American atau Indonesian’s Idol, ternyata ada juga kompetisi model Deep Learning dengan nama ImageNet Large Scale Visual Recognition (ILSVR) Challenge (lihat link resminya). Kompetisi berlangsung dari tahun 2010 hingga tahun 2017. Entah mengapa berhenti di tahun itu, mungkin karena akurasinya yang sudah sangat tinggi mirip kecerdasan manusia.

LeNet

Model ini digagas oleh pakar Deep Learning ternama, Yann LeCun di tahun 98. Mungkin nama “Le” diambil dari “LeCun”. Dengan keterbatasan hardware jaman itu tetapi model ini bekerja sangat baik dengan konsep konvolusi, sehingga sering disebut Convolusion Neural Network (CNN atau ConvNet).

Yann LeCun

AlexNet

Model ini sesuai namanya digagas oleh Alex dan kawan-kawan tahun 2012. Tahun sebelumnya dimenangkan oleh organisasi ternama, yakni Xerox. Model AlexNet banyak dikembangkan oleh organisasi-organisasi lain yang juga memenangkan kontes ILSVRC.

Alex Krizhevsky

GoogLeNet

Google dengan peneliti-penelitinya mampu menang di kontes tahun 2014. Dengan modul insepsi-nya yang mengurangi jumlah parameter AlexNet yang sebesar 60 juta menjadi 4 juta saja.

VGG Net

Model ini memang kalah oleh GoogLeNet, tetapi karena sifatnya yang terbuka, sangat disukai oleh komunitas visi komputer. Akurasinya pun hanya selisah 1 % saja dari GoogLeNet. Berbeda dengan GoogLeNet yang berbasis LeNet dari Yann LeCun, VGG Net berbasis AlexNet.

ResNet

Model ini singkatan dari Residual Neural Network yang menggunakan konsep residual. Gate yang ada di ResNet diterapkan dengan baik oleh Recurrent Neural Network (RNN) untuk data yang berbasis waktu (temporal).

Tokoh DL: Yann Lecun (Fb), Geoffrey Hinton (Google), Yoshua Bengio (Univ Montreal), Source: Link

Untuk menyaingi model-model di atas, walaupun tidak mustahil, sepertinya bagi mahasiswa-mahasiswa kita agak sulit. Hal ini karena model-model di atas dibuat oleh tim dari organisasi-organisasi besar seperti Xerox, Google, Facebook, dan puluhan lainnya. Mungkin kita bisa mengambil metode-metode itu untuk diterapkan di piranti-piranti kecil dan sederhana agar lebih bermanfaat, terutama pada aplikasi-aplikasi online untuk mendukung UMKM. Semoga bisa menginspirasi.

Dari Neural Networks ke Deep Learning

Neural Networks (NN) merupakan machine learning yang sudah dikenal lama. Pasang surut metode ini dapat dijumpai dari rekam jejak penelitiannya. Dari problem utama exclusive or (XOR) yang tidak dapat dikerjakan hingga ditemukannya backpropagation membuat metode ini timbul tenggelam. Termasuk kisah para pelopor bidang ini, dari yang sempat kuliah lagi di kedokteran hingga ada yang harus cuti karena tidak ada uang kuliah. Maklum bidang yang waktu itu masih baru dan belum jelas apakah bisa diselesaikan atau tidak.

Walter Harry Pitts & Jerome Lettvin, Cognitive Science, Source: Link.

Peran Google

Di tahun 2000-an ketika menyusun tesis, laptop yang saya gunakan untuk memproses NN sempat “hang” karen mengelola citra tanda tangan yang berukuran besar. Beberapa peneliti waktu itu, terutama yang dari Indonesia, mengurangi resolusi menjadi sangat kecil, mirip dengan seven segment agar bisa diproses. Terpaksa waktu itu saya menggunakan prinsip encoder agar tidak membuat vektor yang panjang, jadi prinsipnya hanya pencocokan pola, bukan identifikasi pola. Toh hanya digunakan untuk sistem absensi.

Ternyata perkembangan NN, khususnya untuk menangani citra berukuran besar sangat pesat, terutama ditemukannya CNN oleh Yann Lecun. Prinsip konvolusi dibantu dengan pooling mampu menurunkan resolusi citra hingga berukuran kecil tanpa menghilangkan “ciri” lewat preprocessing yang terintegrasi dengan NN. Di sinilah konsep DL muncul, yang di awal-awal sering disebut Deep Neural Network karena memiliki layer dan neuron yang banyak dan dalam.

Tokoh DL: Yann Lecun (Fb), Geoffrey Hinton (Google), Yoshua Bengio (Univ Montreal), Source: Link.

Peran utama Google cukup besar dengan menyediakan konsep tensorflow, serta menyediakan Google Colab untuk dipakai bersama. Hal ini tak luput dari perkembangan hardware yang kian cepat dan murah, terutama memori dan Graphic Processing Unit (GPU) yang bekerja paralel, ditambah lagi Tensor Processing Unit (TPU) yang bekerja hingga level matriks. Saat ini DL mampu memproses citra dengan memasukan unsur waktu/temporal dengan Recurrent Neural Network (RNN) dengan salah satu andalannya Long Short Term Memory (LSTM).

Bagaimana Riset DL Untuk Pemula?

Problem yang muncul adalah bagaimana memulai riset di bidang yang sangat cepat perkembangannya. Beberapa metode seperti VGG, AlexNet, dll bahkan memiliki akurasi yang mendekati 100% sehingga pemula akan kesulitan jika ingin mengalahkan metode-metode tersebut, bisa-bisa kelamaan kuliah doktoralnya.

Untuk mahasiswa master sepertinya tidak ada masalah, karena dengan membandingkan beberapa metode DL untuk kasus terapan di domain tertentu, kemudian membahas mana yang cocok. Nah, mahasiswa doktoral harus menemukan kebaruan/novelty dar metode-metode tersebut. Agak sulit memang tetapi pilihan ada dua, fokus ke metode atau ke domain dimana metode tersebut dipakai. Untuk metode, jika sulit mengalahkan akurasi, bisa mencoba improve di sisi efisiensi, ringan, dan bisa diterapkan di alat-alat kecil (embed). Atau hibrid/menggabungkan dengan metode lain baik di core-nya atau di parameter tertentu, silahkan searching riset-riset terkini.

Untuk fokus ke domain, kita harus belajar penerapan DL, misalnya jika untuk kedokteran, mau tidak mau harus mempelajari bidang spesifik kedokteran tersebut. Misalnya DL untuk mendeteksi COVID lewat hembusan nafas yang di kita dikenal dengan GeNose. Untuk optimasi lahan, misalnya, kita harus mempelajari data spasial serta konsep-konsep Sistem Informasi Geografis.

Bahasa Pemrograman

Saat ini Python masih menjadi andalan untuk menerapkan DL. Banyak contoh-contoh program yang dishare oleh peneliti-peneliti, misalnya via Github. Ketik saja di Google dengan kata kunci: “Colab <metode>”, maka kita segera menemukan Share program Python metode yang dicari tersebut. Tentu saja untuk yang ingin menerapkan ke piranti mobile atau embed terpaksa harus belajar bahasa lain seperti C++ atau Java dan Android.

Berikut video Youtube contoh mempelajari DL, sekaligus bagaimana mengelola data via Google Drive yang efisien dan murah-meriah. Sekian semoga tertarik.

Ngobrol Tentang Deep Learning – Webinar APTIKOM Jabar #1

Salah satu metode machine learning yang saat ini berkembang pesat adalah Deep Learning (DL). Metode ini merupakan kelanjutan dari Neural Networks dengan tambahan preprocessing di layer awal yang berfungsi mengekstrak ciri suatu citra, yaitu konvolusi dan pooling.

Jumlah layer yang banyak beserta neuron-neuronnya membuat DL sulit melakukan proses pelatihan (training) jika menggunakan metode biasa. Dengan hanya mengandalkan hardware biasa, waktu itu laptop sempat ‘hang’ ketika melatih sistem pengenalan tanda tangan dengan ukuran vektor citra yang besar (ribuan bahkan puluhan ribu baris/kolom per objek). Namun saat ini python menyediakan teknik agar proses pelatihan dilakukan di Graphic Processing Unit (GPU) dan Tensor Processing Unit (TPU) bukan hanya mengandalkan CPU. Postingan ini terinspirasi dari hasil webinar tadi pagi dimana saya ditunjuk menjadi moderator.

Akurasi model-model DL saat ini sudah luar biasa tinggi dan hampir mendekati 100%. Terlepas dari riset yang membuat model-model tersebut, beberapa permasalahan masih membutuhkan solusi. Salah satu problem adalah ketika akan menerapkan DL pada piranti-piranti kecil/embedded yang kebanyakan memiliki spesifikasi yang berbeda dengan komputer yang memang dikhususkan untuk komputasi.

DL sudah merambah bidang-bidang lain di luar ilmu komputer misalnya kesehatan, pertanian, geografi, dan lain-lain. Problem utama DL adalah karakternya yang karena menyerupai syaraf makhluk hidup terkadang sulit menemukan logika atau rule yang mendasari pengambilan keputusan model DL, dan menyebutnya dengan istilah black box. Walau bukti akurasi sudah nyata, terkadang seorang dokter membutuhkan alasan yang mendasari keputusan dari suatu model DL. Berbeda jika menggunakan metode fuzzy atau decision tree serta turunannya yang memiliki rule mengapa suatu model DL menyimpulkan suatu hasil.

Pembicara webinar merupakan alumni kampus Jepang. Saya sendiri pernah satu semester diajar oleh dosen alumni Tokyo University dan memang isi kuliah sangat teknis sekali dimana membutuhkan kemampuan matematik, baik aljabar linear untuk pengolahan matriks maupun persamaan diferensial untuk memahami prinsip pelatihan/training, misalnya gradient descent (GD), lavenberg marquadt (LM). Ada juga saran-saran untuk mahasiswa doktoral, khususnya bidang ilmu komputer, antara lain di enam bulan pertama harus segera terjun ke bidang yang digeluti sesuai dengan lab-lab yang ada di kampus, mencari informasi dari periset-periset lain misalnya via Github. Lebih jelasnya silahkan lihat pada Youtube berikut. Sekian semoga bermanfaat.

Belajar Recurrent Neural Network

Neural Network sejak lama diakui memiliki kemampuan mengenali citra atau pola tertentu. Beberapa metode seperti NARXNET telah dipakai untuk proyeksi/peramalan. Jika Deep Learning menggunakan Convolutional Neural Network (CNN) untuk mengenali citra, untuk mengenali data sekuensial Deep Learning menggunakan Recurrent Neural Network (RNN).

Untuk memahami metode RNN, kita banyak menjumpai di internet dengan bentuk animasi-animasi yang membantu memudahkan pemahaman. Jika ebook atau situs blog sulit, silahkan tonton video dari kanal-kanal youtube: https://www.youtube.com/watch?v=LHXXI4-IEns atau https://www.youtube.com/watch?v=Y2wfIKQyd1I. Untuk yang detil mungkin dari Massachusetts Institute of Techonology: https://www.youtube.com/watch?v=SEnXr6v2ifU.

RNN muncul karena CNN tidak sanggup mengklasifikasi data sekuensial/berurutan. Bayangkan kalimat: “i am a boy” dengan 4 buah bag of words (I, am, a, boy) tidak bisa membedakan dengan kalimat: “am I a boy” (lihat: https://www.youtube.com/watch?v=esrv7bahlng).

Untuk memahami RNN, kita harus menguasai dasar-dasar neural network, terutama feed forward beserta fungsi tangen sigmoid. Beberapa library seperti pada TensorFlow, sudah menyediakan fasilitas ini. Google translate memanfaatkan RNN, termasuk juga suggestion kata berikut ketika mengetik. Yuk, belajar implementasinya dengan Python.

Belajar Convolutional Neural Network

Kira-kira belasan tahun yang lalu saya mencoba menggunakan neural network untuk mengenali sebuah pola, misalnya tanda tangan. Beberapa referensi yang saya rujuk menggunakan metode menurunkan resoluse agar bisa diolah di komputer. Hal ini dilakukan karena sebuah objek citra harus dikonversi menjadi vektor yang tadinya matriks 2D. Tentu saja mengurangi resolusi mengakibatkan akurasi yang turun drastis. Namun beberapa tahun kemudian, deep learning diperkenalkan untuk mengatasi hal ini, salah satu tekniknya adalah Convolutional Neural Network (CNN).

Banyak sumber-sumber belajar deep learning di internet. Untuk pemula ada baiknya mencari sumber yang ringan dulu, biasanya disertai dengan simulasi dan durasinya yang kurang dari 10 menit agar tidak lelah, contohnya link youtube ini (https://www.youtube.com/watch?v=oI2rvjbzVmI).

Convolutional

Inti dari CNN selain dari neural network adalah prinsip convolutional, prinsip statistik yang dimanfaatkan untuk preprocessing di layer-layer awal CNN. Jika dulu saya gagal mereduksi neural network karena langsung mereduksi, pada CNN dengan layer convolutional di awal, fitur dapat diekstraksi ciri-nya lewat mekanisme filter. Filter yang digunakan pun lebih dari satu untuk menghasilkan ekstrasi ciri yang baik. Tentu saja ada istilah-istilah khusus pada tahap ini, baik dari cara memproses maupun sekedar istilah-istilahnya.

Pooling

Pooling di sini bermaksud mereduksi ukuran citra hasil convolution agar proses lebih cepat. Bayangkan satu citra berukuran 100×100 piksel maka jika akan diolah oleh neural network akan dikonversi menjadi array berukuran 10000 yang jika diolah dengan komputer langsung hang. Untuk mereduksi, Pooling bekerja dengan mekanisme baik mengambil nilai tertinggi dalam satu matriks ukuran tertentu (max pooling), misalnya 3×3, atau dengan mencari rerata dari matriks itu.

Fully Connected

Ini merupakan metode yang dipakai dalam neural network. Bedanya di sini karena mekanisme convolutional ada beberapa citra hasil filtrasi (jika lebih dari satu filter). Satu hal yang unik dari CNN adalah penggunakan fungsi softmax di akhir proses yang berisi angka-angka probabilitas. Nilai tertinggi merepresentasikan kelas terpilih hasil klasifikasi. Salah satu manfaat dari banyaknya sumber belajar di internet adalah kita bisa memilih mana satu sumber yang cocok dengan style kita. Jika di satu ebook/video/blog kurang dimengerti, segera cari sumber lain. Sekian, selamat belajar deep learning.

Membuat Tensor Sederhana dengan TensorFlow pada Google Colab

Istilah tensor dijumpai dalam matematika, khususnya dalam aljabar. Tensor sebenarnya bentuk umum dari besaran, jika dimensinya nol berarti skalar dan jika berdimensi satu ke atas, maka disebut vektor dan matriks. Istilah tensor digunakan juga oleh Google dalam library python “TensorFlow”. Istilahnya mirip tensor, terutama ketika mengelola vektor dan matriks.

Dalam penerapannya, TensorFlow sedikit membingungkan karena memiliki dua fase: konstruksi dan eksekusi. Tensor ketika digunakan berupa graph yang berisi nodes dan edges. Jika nodes berisi operasi, edges berisi tensor. Sementara itu, fase eksekusi membutuhkan session.

Untuk lebih jelsnya silahkan buka Google Colab. Buat satu notebook baru, beri nama misalnya FirstTensor.ipynb. Disini kita akan membuat satu tensor sederhana yang berisi satu variabel konstant 30. Operasi yang dilakukan adalah mencetak (print) konstanta tersebut. Masukan kode berikut dalam sel colab tersebut.

Di sini tensorflow versi 1.x digunakan. Secara default Colab menyediakan versi 2.x. Perhatikan sel pertama berisi impor library tensorflow. Line pertama merupakan instruksi standar penggunaan tensorflow versi 1. Sel kedua berisi konstruksi variabel konstan x=30. Selain itu dibuat satu session dengan nama “sess” yang kemudian dioperasikan berupa fungsi print.

Sepertinya agak ribet karena untuk mencetak konstanta 30 saja butuh beberapa line. Namun mengingat satu sesi bisa diterapkan untuk satu prosesor (GPU) maka komputasi bisa dilakukan dengan banyak prosesor yang bekerja secara paralel. Jadi walau agak sedikit merepotkan di awal tetapi ketika diterapkan dengan banyak prosesor, hasilnya lebih cepat. Biasanya diterapkan dalam sebuah framework deep learning. Sebagai ilustrasi, tensor dalam graph di bawah ini.

Hasil perkalian a dan b akan dikurangi hasil penjumlahan b dan c. Instruksi pythonnya adalah sebagai berikut menlanjutkan dari instruksi sebelumnya.


import numpy as np
a = tensorflow.constant(np.array([5, 7, 10]))
b = tensorflow.constant(np.array([2, 3, 21]))
c = tensorflow.constant(np.array([3, 5, 7]))
d = a * b  # tensorflow.multiply(a,b)
e = c + b  # tensorflow.add(c,b)
f = d - e  # tensorflow.subtract(d,e)
sess = tensorflow.Session()
outs = sess.run(f)
sess.close()
outs

Jalankan dan hasilnya harus sama dengan gambar di atas [5,13,182]. Selamat mencoba tensor dalam tensorflow.

Ref:

Self-Supervised Learning di AIS 2020

Hari ini ada acara spesial yakni Artificial Intelligence Summit (AIS) 2020. Beberapa keynote akan dilaksanakan. Salah satunya nanti Yann LeCun, penemu self-supervised learning. Hari ini pengenalan Self-Supervised Learning (SSL) diberikan oleh Prof Bambang dari ITB. Ide menarik dari metode ini adalah bahwa manusia belajar ketika anak-anak sebagian besar tanpa “supervised”/panduan. Mereka menggunakan self-supervised yang dalam SSL dikenal dengan kombinasi pretext dan downstream task.

Jenis pretext task ada banyak antara lain: rotation, colorization, in-painting, jigsaw, placing image patches, dan lain-lain. Presentasi disertai dengan demo program menggunakan Google Colab, lihat di sini programnya. Disertakan pula link Github sumbernya. Silahkan lihat record-nya di Youtube, atau video di bawah ini.

Adaptive Neuro-Fuzzy Inference System (ANFIS) dengan Python

Adaptive Neuro-Fuzzy Inference System (ANFIS) merupakan metode yang menggabungkan Jaringan Syaraf Tiruan (JST) dengan Fuzzy. Konsepnya adalah menjadikan “rule” sebagai “neuron”. Jumlah layer tersembunyi (hidden) hanya satu layer. Salah satu situs yang OK untuk mempraktikan ANFIS dengan bahasa pemrograman Python adalah salah satu TIM dari MIT di link berikut ini. Source code bisa diunduh dan penjelasannya lewat situs Github.

Instal Library ANFIS

Anaconda tidak memiliki pustaka ANFIS, oleh karena itu perlu mengunduh menggunakan PIP. Selain itu pustaka yang dibuat sendiri juga disertakan, misalnya anfis.py dan folder membership yang berisi dua file penting lainnya. Untuk mengetahui bagaimana fungsi eksternal bekerja silahkan lihat postingan saya yang lalu.

Menggunakan Google Colab

Memang lebih mudah menggunakan Google Colab karena sebagian besar pustaka sudah tersedia. Hanya saja untuk ANFIS terpaksa harus menginstal terlebih dahulu. Caranya adalah seperti instalasi PIP lewat terminal, hanya saja disini menggunakan tanda seru di awalnya.

Ketik !pip install anfis. Tunggu beberapa saat hingga Google Colab berhasil mengunduh dan menginstal pustaka ANFIS tersebut. Jangan lupa, file-file pendukung unggah di bagian File di sisi kiri Google Colab. Pastikan ketika impor pustaka di sel berikutnya berhasil. Buat folder baru dengan nama membership lalu isi dengan file pendukungnya. Jangan diletakan di luar semua.

Berikutnya adalah mengambil data latih dari file “beasiswa.txt”. Pastikan X dan Y sesuai dengan yang diinginkan sebagai data latih dan targetnya. Silahkan cari sumber referensi mengenai membership function. Di sini mf berfungsi mem-fuzzy-kan inputan. Jalankan dan pastikan grafik performa pelatihan muncul.

Perhatikan hasil latih yang berwarna merah sudah mendekati target yang berwarna biru. Satu untuk memperoleh beasiswa dan nol untuk yang tidak memperoleh beasiswa. Gunakan satu data sampel untuk menguji apakah menerima beasiswa atau tidak.

Perhatikan untuk input1 3.2 dan input2 3.4 hasilnya adalah 1. Silahkan menggunakan fungsi “round” untuk membulatkan apakah nol atau satu. Untuk jelasnya lihat video berikut ini. Sekian semoga bermanfaat.

Merekam Riwayat Pembelajaran Jaringan Syaraf Tiruan dengan Checkpoint

Training pada Jaringan Syaraf Tiruan (JST) biasanya terdiri dari beberapa epoch, sebuah satuan yang mirip iterasi (lihat pos yang lalu tentang istilah ini). Hasil pelatihan biasanya diperoleh dari epoch terakhir. Jika ingin mengetahui bias dan bobot tiap epoch perlu menggunakan fasilitas checkpoint pada Keras. Postingan ini bermaksud membahas penggunaan checkpoint.

#membuat model JST
model = keras.models.Sequential([
keras.layers.Dense(30, activation="relu", input_shape=[2]),
keras.layers.Dense(30, activation="relu"),
keras.layers.Dense(1)
])
model.summary()
#compile
model.compile(optimizer='Adam',loss='binary_crossentropy',metrics=['accuracy'])
checkpoint_cb = keras.callbacks.ModelCheckpoint("Model-{epoch:02d}.h5")
#training dengan checkpoint
history = model.fit(x_train, y_train, epochs=5,
validation_data=(x_val, y_val),
callbacks=[checkpoint_cb])

Tampak arsitektur JST sederhana di atas ditambahkan fasilitas checkpoint. Karena menggunakan library Keras, maka perlu diimpor Keras di awal dan pastikan library tersebut sudah diunduh terlebih dahulu jika menggunakan Jupyter Notebook. Namun jika menggunakan Google Colab tidak perlu karena sudah terpasang di situs online itu, hanya saja perlu mendefinisikan versi TensorFlownya (gunakan versi 1.x).

Perhatikan lima epoch tersebut, tampak lima buah model terbentuk yang berisi bias dan bobot hasil pelatihan tiap epoch. Jika ada 100 epoch tentu saja akan ada 100 model, oleh karena itu perlu menggunakan jenis checkpoint lain, misalnya best model saja yang tersimpan. Untuk jelasnya silahkan lihat video saya berikut ini.

Format Hasil Training Jaringan Syaraf Tiruan Pada Matlab dan Python

Jaringan Syaraf Tiruan (JST) merupakan salah satu metode computational intelligence (CI) yang meniru sifat otak makhluk hidup. Sel neuron otak direplika dalam suatu fungsi transfer/aktivasi yang kemudian ditransfer ke neuron lainnya lewat sebuah jaringan. Sebuah bobot dan bias mengatur apakah suatu sinyal diteruskan atau tidak sehingga keluaran menghasilkan nilai sesuai dengan keinginan. Untuk mengatur bobot dan bias diperlukan sebuah proses pembelajaran yang dikenal dengan nama learning/training. Karena ketika training membutuhkan data dan target atau label, maka pembelajarannya dikenal dengan istilah pembelajaran terpandu (supervised learning). Beberapa tipa JST tidak membutuhkan target/label, seperti misalnya tipe Self Organizing Map (SOM).

Bahasa Pemrograman JST

Berbagai bahasa pemrograman dapat digunakan untuk membuat JST, seperti bahasa C++, Java, Matlab, Python dan lain-lain. Matlab memiliki toolbox yang mempermudah proses pelatihan. Dengan adanya toolbox, beberapa peneliti yang hanya fokus ke penerapan metode tidak perlu kehabisan waktu dalam pemrograman. Di sisi lain Python yang kian hari kian diminati memiliki library Scikit Learning, yang menyediakan fasilitas-fasilitas dalam pelatihan JST.

Matlab

Tersedia toolbox NNTOOL dalam pembuatan JST. Sebelumnya Matlab juga memiliki beberapa fungsi untuk pembuatan JST seperti newff, newcf, dan lain-lain tergantung tipe network yang akan dibuat. Jika ingin menghasilkan performa yang kuat, Matlab masih kalah dengan C++ yang bagi beberapa orang sangat sulit membuat programnya, terutama dalam memanipulasi array dan matriks. Namun Matlab seperti alat ukur sangat mudah digunakan sehingga sebuah artikel ilmiah yang mengusulkan metode baru dapat juga dilihat oleh orang lain (direplikasi), sehingga banyak digunakan dalam naskah artikel ilmiah. Untuk pembuatan GUI untuk penerapan, Matlab menyediakan fasilitas pembuatan GUI desktop, sementara belum ada yg versi berbasis web.

Python

Bahasa pemrograman ini saat ini banyak diminati. Masalah array dan matriks dapat diatasi lewat library-librarynya seperti NumPy dan Pandas. Ketangguhan bahas ini membuat Google menerapkannya dalam fasilitas pemrograman onlinenya di http://colab.research.google.com. Framework yang digunakan adalah Jupyter Notebook. Selain itu, Google juga menggratiskan GPU dan TPU nya yang kita kenal memiliki server yang kuat. Sehingga dengan bermodal ponsel dapat menjalankan machine learning dengan ketangguhan setara server Google. Berbeda dengan Matlab yang hanya menyediakan fasilitas GUI pada aplikasinya, Python menyediakan dua versi yaitu desktop dengan library TKinter dan web-based lewat framework Django, Flask, dan Jinja2 sebagai template web-python.

Hasil Pelatihan

Pelatihan JST menghasilkan nilai-nilai parameter antara lain arsitektur JST berupa susunan layer dan jumlah neuron di tiap-tiap layer, serta bobot dan bias di masing-masing layer. Pada Matlab, hasil tersimpan dalam format *.mat yang berisi variabel network hasil pelatihan. Untuk memakainya sebuah instruksi diperlukan yaitu fungsi “load” yang memanggil file mat tersebut.

Untuk Python, beberapa versi yang digunakan adalah *.pkl dan *.h5. Yang paling mudah adalah *.h5 yang merupakan tipe sequential, dimana network mengalir dari input ke output. Karena *.h5 berisi bobot dan bias hasil training, untuk menggunakannya diperlukan file lain yaitu file *.yaml yang berisi arsitektur JST (jumlah layer dan neuron). Hasil pelatihan penting untuk diketahui oleh pengembang software terutama ketika membuat penerapan JST hasil training. Aplikasi di web biasanya tidak memerlukan proses training yang memakan beban server, melainkan hanya menggunakan hasil training untuk penerapan, misalnya klasifikasi.

Pilihan ada di tangan Anda. Beberapa pengguna non-computer science seperti bidang elektronika, ekonomi, kesehatan, dan lain-lain banyak menggunakan kemudahan Matlab, dengan resiko membeli lisensi yang cukup mahal. Jika Anda dari computer science alangkah baiknya memilih kedua-duanya. Lho kok dua-duanya? Ya harusnya orang computer science bisa semua bahasa, minimal pernah mencoba. Sekian, semoga bermanfaat.

Cross Validation dengan Scikit-Learning Python

Selain dengan membagi data latih dengan data validasi/testing dengan proporsi tertentu misalnya 70/30 (lihat pos terdahulu untuk split data), teknik lain yang terkenal dan sangat dianjurkan adalah validasi silang (cross validation). Metode ini mirip split data tetapi dengan mentraining ulang data latih yang dirubah menjadi data testing dan sebaliknya. Dikenal dengan istilah K-Fold Cross Validation dengan K berarti jumlah sub pelatihannya. Perhatikan 5 data grup pelatihan pada 5-Fold Cross Validation berikut.

Masing-masing grup split terdiri dari 4 data latih dan 1 data uji yang berwarna biru. Bagaimana dengan akurasinya? Mudah saja. Kita tinggal merata-ratakan berapa akurasi tiap pelatihan.

Menggunakan Jupyter Notebook/Google Colab

Berikutnya kita coba menggunakan data latih bawaan Scikit-Learning. Gunakan kode berikut yang diambil dari situs resminya ini.

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn import svm
X, y = datasets.load_iris(return_X_y=True)
from sklearn.model_selection import cross_val_score
clf = svm.SVC(kernel='linear', C=1)
scores = cross_val_score(clf, X, y, cv=5)
scores

Perhatikan baris terakhir yang memangil fungsi cross validation dengan cv=5. Jalankan maka anda akan memperoleh akurasinya. Di sini diambil contoh menggunakan SVM. Berikut tampilan dengan menggunakan Google Colab.

Jika dirata-rata akurasinya adalah (0.967 + 1 + 0.967 + 0.967 + 1)/5 sekitar 0.98 (98%) yang berarti sangat akurat dengan lima kali cek akurasi dengan 5 grup split data berbeda.  Untuk Cross Validation pada Jaringan Syaraf Tiruan silahkan lihat video di bawah. Sekian, semoga bermanfaat.

Membagi Data Latih dan Uji Secara Otomatis Pada Python

Sebenarnya menggunakan data yang kita ambil sekaligus menjadi data latih dan uji tidak diperkenankan. Namun permasalahan itu dapat diselesaikan dengan membagi data yang kita peroleh menjadi data latih dan data uji, misalnya dengan proporsi 70% untuk data latih dan sisanya 30% untuk data uji. Di sini istilah data uji pun kurang pas, yang pas adalah data validasi, mengingat data uji seharusnya diambil dari data di luar data yang kita kumpulkan, dan seharusnya data terkini yang baru saja diambil di luar data latih dan validasi.

Mengapa harus memisahkan data latih dengan data uji? Jawabannya adalah menghindari terjadinya overfitting, yaitu suatu kondisi pelatihan yang hasil uji terhadap data yang dilatih sangat bagus tetapi diuji oleh data lain yang tidak digunakan dalam pelatihan sangat buruk. Overfitting terjadi karena kegagalan model dalam proses generalisasi.

Split Data dengan Skicit-Learning

Python menyediakan satu library terkenal bernama Skicit-Learning yang berisi metode-metode mesin pembelajaran dalam proses regresi, klasifikasi, pengolahan data, dan lain-lain. Fungsi yang disediakan adalah train_test_split dengan parameter berupa proporsi data untuk pengujian. Skicit-Learning atau disingkat Sklearn menyediakan juga sampel data untuk uji coba metode-metode yang ada. Kode berikut membagi data irish menjadi 60% data latih dan 40% data uji. Gunakan Jupyter Notebook atau Google Colab untuk mencoba kode berikut.

  • import numpy as np
  • from sklearn.model_selection import train_test_split
  • from sklearn import datasets
  • from sklearn import svm
  • X, y = datasets.load_iris(return_X_y=True)
  • X.shape, y.shape
  • X_train, X_test, y_train, y_test = train_test_split(
  • X, y, test_size=0.4, random_state=0)
  • X_train.shape, y_train.shape
  • X_test.shape, y_test.shape
  • clf = svm.SVC(kernel=’linear’, C=1).fit(X_train, y_train)
  • clf.score(X_test, y_test)

Contoh di atas menggunakan Support Vector Machine (SVM) dalam melatih model dan mengujinya. Hasil tampil lewat fungsi score.

Tampak akurasi yang dihasilkan sebesar 96,7% ketika diuji dengan data tes sebanyak 40% (test_size=0.4 di kode di atas). Sekian dan semoga bisa sedikit membantu.

Source: scikit-learn.org/stable/modules/cross_validation.html#cross-validation

Mengetahui RULE Hasil Training ANFIS.

Berbeda dengan JST yang hasil trainingnya mirip “black box” yang tidak diketahui logikanya, pada Adaptive Neuro-Fuzzy Inference System (ANFIS) hasil trainingnya memiliki logika. Logika ini dikenal dengan istilah RULE. Postingan ini bermaksud menunjukan bagaimana melihat RULE hasil training. Masukan data training, misalnya data yang mirip Logika XoR.

Buka ANFIS editor dengan mengetik “anfisedit” pada command window. Masukan data latih tersebut. Gunakan “From: worksp”.

Rancang FIS yang akan dilatih dengan menekan “Generate FIS” di editor ANFIS.

Di sini di isian “Number of MFs” berisi “3 3” yang artinya tiga kelas input1 dan input2, misal “baik”, “cukup”, “kurang”, bisa juga diganti “2 2” jika hanya dua kategori, misal “baik” dan “buruk” saja. Tentu saja makin banyak kategori biasanya hasil lebih baik, apalagi jika datanya sedikit seperti kasus di contoh ini. Lanjutkan dengan menekan “Train Now”. Jika sudah perhatikan RULE yang terbentuk dengan menekan “Edit” – “Rule”.

In1mf1, dan seterusnya bisa diedit dengan bahasa yang kita mengerti, dengan cara masuk ke menu “edit” – “FIS Proerties”. Mirip caranya dengan mengedit fuzzy inference system (FIS). Berbeda dengan Jaringan Syaraf Tiruan (JST), ANFIS memiliki keunggulan dimana hasil training memiliki logika tertentu. Selanjutnya, uji dengan data sesungguhnya yaitu Logika XoR. Sebelumnya simpan ke “Workspace” misalnya dengan nama “xor”.

Testing dengan data sesungguhnya, yaitu logika XoR.

Jalankan dengan fungsi “evalfis” untuk menguji data “xorlogic” tersebut (kolom 1 dan 2) apakah sama dengan targetnya (kolom 3), yaitu beruturut-turut 0, 1, 1, 0.

Perhatikan “result” dengan jawaban logika xor yang asli, jika result dibulatkan (ketik “round(ans)”) akan menghasilkan jawaban sesungguhnya, alias akurat 100%. Selamat mencoba.

 

 

Mempersiapkan Data dan Training Model ANFIS, JST dan SVM

Dalam machine learning dikenal beberapa jenis data antara lain: data training dan data testing. Terkadang data training dipisah menjadi data training dan target. Dalam prakteknya, data training menggunakan sebagaian prosentase dengan sisanya dijadikan data tasting untuk pengujian model.

Excel dapat digunakan untuk mempersiapkan data training walaupun memiliki beberapa keterbatasan dalam mengelola “big data”. Untuk data yang tidak terlalu besar, aplikasi bawaan ms office ini cukup dapat diandalkan.

Walaupun cross validation banyak diterapkan saat ini, tetapi dengan 80% data training dan sisanya untuk testing (20%) sudah cukup untuk mengukur akurasi model yang dirancang. Sebagai contoh data training berikut dapat digunakan, dengan data latihnya. Berikut langkah proses mempersiapkan data training dan data testing.

1. ANFIS

Untuk ANFIS data training dan target digabung menjadi satu. Formatnya karena sudah sesuai dengan format pentabelan di Excel maka cukup menyiapkan data training saja. Gunakan dua kode ini untuk mengimport data dengan Matlab.

  • load(‘data.dat’);
  • load(‘testing.dat’);

Untuk ANFIS, fungsi “anfisedit” disediakan Matlab untuk melatih ANFIS lewat data yang ada. Karena isian sudah dalam bentuk DAT maka sebenarnya dua kode di atas hanya digunakan nanti untuk testing dan training lewat model lainnya seperti JST, SVM, dll.

Pastikan training data muncul dengan tiga kelas sesuai dengan data (kelas 1, 2 dan 3). Berikutnya “Generate FIS” diklik untuk meramu FIS yang masih kosong.

Angka 3 di atas berarti ada 3 komponen MF di tiap input. Jumlah angka yang muncul menandakan jumlah masukan, di sini ada empat input yang merupakan variabel penentu output. Tipe MF ada banyak, di sini akan digunakan “trimf” yang paling sederhana (linear). Gunakan saja defaultnya (3 komponen di tiap inputan), yang merepresentasikan kondisi “low”, “medium”, dan “high”. Output gunakan saja konstan. ANFIS hanya tersedia di jenis fuzzy “Sugeno”. Tekan “Struktur” di sisi kanan untuk melihat sekilas Network yang siap dilatih.

Berikutnya masuk ke panel “Train FIS” untuk melatih Network. Ada dua pilihan pembelajaran: hybrid dan backpropagation. Gunakan saja “hybrid”. Berikut merupakan hasil training dengan 3 epoch (mirip iterasi).

Error tampak di layar utama (sekitar 0.1445). Simpan hasil pelatihan lewat “File” – “Export” – Pilih file.

Setelah nama fuzzy diisi (berekstensi *.fis) maka model siap diuji dengan data testing yang sudah ada. Misalnya diberi nama “anfisiris.fis”. Untuk testing gunakan kode berikut ini:

  • anfisiris=readfis(‘anfisiris.fis’);
  • prediksi=evalfis(testing(:,1:4);
  • tes=testing(:,1:4)
  • hasil=evalfis(tes,anfisiris)

Terakhir adalah menghitung akurasi dengan cara prosentase MAPE (Mean Average Percentage Error)-nya:

Jika dibandingkan maka akan tampak beberapa yang error, misalnya di sini ada satu yang error, jadi nilai MAPE-nya= 1/39 *100 = 2,56 %. Atau akurasinya = 100-2,56 = 97,44%. Sedangkan jika ingin mengetahui prediksi mana saja yang tidak akurat dapat menggunakan matriks confusion.

  • target=testing(:,5);
  • target=transpose(target);
  • prediksi=transpose(round(hasil));
  • c=confusionmat(target,prediksi)
  • c =
  • 13 0 0
  • 0 13 0
  • 0 1 12

Cara membaca matriks confusion adalah sebagai berikut. Kolom merupakan prediksi sementara baris adalah aktualnya (dalam hal ini sama dengan target (testing di kolom kelima). Fungsi “round” ditambahkan pada hasil untuk mencari kelas prediksi terdekat, misalnya 2.7 dikategorikan kelas “3”. Diagonal pada matriks confusion menyatakan akurasi. Perhatikan di baris kedua kolom ketiga, di sini harusnya 13 tetapi berisi 12 karena ada satu prediksi 3 (baris ketiga) tetapi kenyataannya 2 (kolom kedua).

2. Neural Networks (Jaringan Syaraf Tiruan)

JST perlu memisahkan data training dengan target (labelnya). Selain itu, formatnya juga berbeda dengan data pada ANFIS, dimana variabel berdasarkan baris. Untuk itu perlu modifikasi data yang ada berdasarkan “data.dat” dan “testing.dat”. Berikut ini kode untuk data training dan targetnya.

  • load(‘data.dat’);
  • load(‘testing.dat’);
  • datalatih=data(:,1:4);
  • datalatih=transpose(datalatih);
  • target=data(:,5);
  • target=transpose(target);

Coba cek dengan fungsi “size”, pastikan jumlah baris merepresentasikan jumlah variabel, sementara jumlah kolom merepresentasikan jumlah data. Berikutnya buat JST kosong dan latih.

  • network=newff(datalatih,target,[81 81]);
  • network=train(network,datalatih,target);

Perlu disiapkan data untuk testing.

  • tesdata=testing(:,1:4);
  • tesdata=transpose(tesdata);
  • targettes=testing(:,5);
  • targettes=transpose(targettes);

Selanjutnya menggunakan fungsi “sim” untuk memprediksi.

  • hasil=sim(network,tesdata);
  • aktual=targettes;
  • prediksi=round(hasil);
  • c=confusionmat(aktual,prediksi);
  • c =
  • 13 0 0 0
  • 0 11 2 0
  • 0 4 6 3
  • 0 0 0 0

Dari matriks confusion di atas dapat diketahui precision-nya (atau dikenal juga dengan nama MAPE). Caranya adalah membandingkan total yang benar (angka di sisi diagonal) dengan total data testing.

  • 13+11+6
  • ans =
  • 30
  • ans/39
  • ans =
  • 0.7692

Akurasi yang dihasilkan (MAPE) adalah 76.92%.

3. Support Vector Machine (SVM)

SVM hanya memisahkan dua kelas yang berbeda. Jika ada lebih dari dua kelas, maka perlu modifikasi dengan menggunakan lebih dari satu garis pemisah. Salah satu tekniknya adalah membuat pohon keputusan. Misalnya ada tiga kelas (kelas 1, kelas 2 dan kelas 3) maka perlu dibuat tiga garis pemisah, misalnya kita beri nama svm1, svm2 dan svm3.

  • svm1, pemisah antara kelas 1 dan kelas 2
  • svm 2, pemisah antara kelas 1 dan kelas 3, dan
  • svm 3, pemisah antara kelas 2 dan kelas 3

 

(source: link)

Selanjutnya, dibuat logika if-else untuk mengarahkan garis pemisah yang sesuai (atau dengan teknik lain yang sesuai). Berikut ini salah satu contohnya:

  • test1=svmclassify(svm1,datatesting)
  • if test1==1
  • test2=svmclassify(svm2,datatesting)
  • if test2==1
  • class=’1′
  • else
  • class=’3′
  • end
  • else
  • test3=svmclassify(svm3,datatesting)
  • if test3==2
  • class=’2′
  • else
  • class=’3′
  • end
  • end

Untuk membuat garis pemisah, Matlab menyediakan fungsi “svmtrain”. Jika ingin membuat garis pemisah antara kelas 1 dan kelas 2 (svm1) diperlukan data latih yang memiliki kelas 1 dan kelas 2 (tanpa menyertakan kelas 3) disertai dengan group-nya (dalam JST dikenal dengan istilah target).

  • svm1=svmtrain(train,group)

Di sini “train” merupakan data gabungan kelas 1 dan kelas 2, begitu pula “group” merupakan kelas yang sesuai dengan “train”. Gunakan excel untuk memilah-milah antara kelas 1 dengan kelas lainnya untuk membuat svm2, dan svm3.

 

Competitive Network dan Contoh Implementasinya

Tipe network ini menghasilkan keluaran yang terbesar sebagai pemenang. Misal ada tiga input sebesar 1,2, dan 3, maka pemenangnya adalah input ketiga (sebesar 3). Berikut notasi standar competitive network.

Fungsi competitive network pada matlab adalah “compet”. Buka command window pada Matlab dan coba fungsi “compet”. Untuk lebih jelasnya silahkan buka help dengan mengetik “help compet” di command window.

  • a=[1;2;3];
  • compet(a)
  • ans =
  • 0
  • 0
  • 1
  • compet(-a)
  • ans =
  • 1
  • 0
  • 0

Perhatikan kode di atas. Jika ingin menemukan nilai tertinggi gunakan fungsi compet(a) sementara jika ingin mencari terendah, gunakan compet(-a). Biasanya mencari nilai terendah digunakan dalam menentukan mana yang paling mirip (similar) antara beberapa hasil output. Tentu saja ada sedikit modifikasi kode untuk memberitahu hasil minimum suatu inputan.

Misal kita beri nama tiga input tersebut berturut-turut “nilai A”, “nilai B” dan “nilai C”. Maka sistem diminta menampilkan nilai mana yang terkecil? Lanjutkan dengan kode berikut ini.

  • input1=[“nilai A”;”nilai B”;”nilai C”];
  • hasil=compet(-a);
  • [ind,result]=find(hasil);
  • minimum=input1(ind)
  • minimum =
  • “nilai A”

Lebih simple dibandingkan dengan menggunakan “if-else” berikut ini yang jauh lebih panjang jumlah baris programnya, apalagi yang akan dibandingkan sangat banyak.

  • if (a(1)<a(2)) && (a(1)<a(3))
  • minimum=’Nilai A’
  • else
  • if a(2)<a(3)
  • minimum=’Nilai B’
  • else
  • minimum=’Nilai C’
  • end
  • end
  • minimum =
  • ‘Nilai A’