Random Forests dengan Google Colab Python

Decision Tree (DT) merupakan metode machine learning klasik yang memiliki keunggulan dari sisi interpretasi dibanding Deep Learning (DL). Memang akurasi Deep Learning, terutama yang digunakan untuk mengolah citra sudah hampir 100% tetapi beberapa domain, misalnya kesehatan membutuhkan model yang dapat dilihat “isi” di dalamnya. Kita tahu bahwa DL sering dikatakan “black box” karena tidak dapat diketahui alur di dalamnya. Nah, di sinilah DT digunakan karena memiliki keunggulan dari sisi transparansi. Bahkan ketika DT terbentuk kita bisa memprediksi secara manual hasil akhir dengan melihat alur DT tersebut tanpa bantuan komputer. Silahkan lihat pos saya terdahulu tentang DT.

Nah, karena data yang besar terkadang DT sangat sulit terbentuk. Seorang peneliti dari IBM bernama Tin Kam Ho membuat algoritma DT di tahun 1995 (saya baru masuk S1 FT UGM waktu itu). Prinsipnya adalah membuat DT-DT kecil secara acak kemudian digunakan untuk memprediksi melalui mekanisme voting. Misalnya kita ingin memprediksi sesuatu dengan enam buah Trees di bawah ini.

Jika hasilnya 2 Yes dan 4 No maka secara voting hasil prediksinya adalah No karena yang terbanyak No. Oiya, Tree yang dibentuk di atas ketika memilih root dan node tidak perlu menggunakan kalkulasi njlimet seperti DT yaitu dengan Entropi dan Gain Information.

Bagaimana menerapkan lewat bahasa pemrograman? Python memiliki library Scikit Learning untuk Random Forests. Oiya, jika ingin melihat kode di dalam library tersebut silahkan buka saja Source di Github yang disediakan oleh Scikit Learning. Jika ingin memodif silahkan tiru-amati-modifikasi source code tersebut, khususnya para mahasiswa doktoral yang fokus ke metode. Untuk lebih jelasnya silahkan lihat link Video saya di Youtube berikut ini. Sekian, semoga bermanfaat.

Support Vector Regression Untuk Prediksi Sebaran COVID-19

Support Vector Regression (SVR) merupakan metode klasik yang memanfaatkan teori matematika dan statistik untuk regresi dengan model Support Vector Machine (SVM). Jadi SVM ternyata bukan hanya untuk klasifikasi melainkan juga untuk regresi dan deteksi outliers.

Silahkan gunakan Scikit Learning untuk bahasa Python. Postingan ini mengilustrasikan penggunaannya dengan Google Colab. Data COVID dapat kita temukan di internet, atau silahkan gunakan file Excel link ini. Pilih negara yang ingin Anda prediksi kemudian simpan dalam bentuk file. Berikut kira-kira kode programnya.

#impor pustaka svm
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVR
from google.colab import files
import io
#data latih
upload_files = files.upload()
for filename in upload_files.keys():
x=upload_files[filename].decode(‘utf-8’)
data1 = pd.read_csv(io.StringIO(x), header=None)
#print(data1.head())
X1=np.asarray(data1)
x_train=X1[0:,0:1]
y_train=X1[0:,1:2]
#membuat model (classifier)
clf = SVR(kernel=‘poly’, C=100, gamma=‘auto’, degree=2, epsilon=.1,
oef0=1)
clf.fit(x_train,y_train)
#prediksi data
test=x_train.reshape(-1,1)
y_pred=clf.predict(test)
y_next=np.array([[457],[465],[470],[471],[480]])
prednext=clf.predict(y_next)
print(prednext)
#Visualisasi Data
absis=[x_train]
ordinat=[y_train]
#ordinat2=np.concatenate([x_train],[prednext])
plt.scatter(absis, ordinat, cmap=‘flag’, marker=‘o’)
plt.scatter(absis, y_pred, cmap=‘flag’, marker=‘x’)
plt.scatter(y_next, prednext, cmap=‘flag’, marker=‘x’)
#Label
plt.xlabel(“Day”)
plt.ylabel(“Number of infected People”)
plt.title(“Projection Pattern of COVID-19 Spread in India”)
plt.grid()

Jika dijalankan, masukan saja data CSV yang Anda ingin prediksi dan tunggu beberapa saat, agak lama karena 400-an hari (lebih dari setahun). Jika selesai pastikan hasil prediksi muncul.

Tampak garis biru merupakan data asli dari Excel sementara garis oranye merupakan hasil fitting berdasarkan kernel polinomial (kuadratik). Lima tanggal prediksi tampak di ujung kanan berwarna hijau. Silahkan lihat video lengkapnya di chanel saya. Sekian, semoga bisa menginspirasi.

P.S. Tulisan di atas sebagian diambil dari publikasi kami di https://ieeexplore.ieee.org/document/9415858

Naïve Bayes – Kalkulasi secara Manual dan dengan Komputer

Saat ini tidak dapat dipungkiri bahwa Deep Learning paling banyak diteliti dan digunakan dalam aplikasi-aplikasi artificial intelligence. Beberapa pengguna tidak menyukai metode tersebut karena karakteristiknya yang tidak dapat dilihat logika di dalam modelnya atau sering diistilahkan dengan black box walaupun akurasinya saat ini dengan model terbarunya hingga mendekati 100%. Selain itu, deep learning membutuhkan kinerja prosesor yang tinggi, terutama ketika proses pelatihan (learning).

Jika ingin membuat model yang dapat dilihat alur logikanya, naïve bayes merupakan salah satu pilihan yang baik. Walaupun kinerjanya menurut beberapa penelitian kalah dengan metode terkini seperti misalnya support vector machine (SVM), metode ini memiliki karakteristik statistik yang kental, yaitu probabilistik. Ada istilah confidence dalam metode ini.

Untuk perhitungan, naïve bayes lebih mudah menurut saya dibanding decision tree yang mengharuskan membuat model tree dengan konsep entropy dan gain informationnya. Pada naïve bayes, kita hanya menghitung probabilitas ketika menghitung confidence tiap-tiap kelas prediksi.

Plus Minus

Metode naïve bayes, dalam Scikit Learn diisitilahkan dengan Gaussian Naïve Bayes, karena dalam mengkonversi tabel kategorikal lewat pendekatan fungsi Gauss. Walaupun akurasinya kurang dibanding metode lain, sifat probabilistiknya sangat membantu penjelasan ke pengguna dalam aplikasinya. Misalnya dalam memprediksi sebuah sentimen dalam sentiment analysis, metode ini tidak hanya menjelaskan positif, negatif, atau netral saja, melainkan berapa kadar positif dan negatifnya dalam bentuk probabilitas. Terkadang jika dalam sistem dashboard menunjukan negatif dengan probabilitas yang tinggi bisa saja digambarkan dengan warna merah yang artinya warning, sehingga eksekutif segera mengambil tindakan yang perlu dalam manajemen.

Statistik merupakan bidang yang paling banyak dimanfaatkan dalam machine learning. Belakangan beberapa ahli machine learning enggan disebut ahli statistik karena belakangan metode-metode terbaru tidak terlalu mengadopsi konsep statistik, misalnya tensorflow yang cenderung ke arah tensor dan matriks dalam aljabar. Silahkan lihat penjelasan slide di atas dalam video youtube berikut ini, semoga bermanfaat.

Pohon Keputusan (Decision Tree)

Pohon keputusan merupakan satu metode klasik dalam prediksi/klasifikasi. Tekniknya adalah dengan menggunakan pertanyaan di suatu atribut (disebut test attribute) kemudian mengarahkan ke cabang mana sesuai dengan jawabannya. Tugas utama dalam metode ini adalah model membuat pohon/tree berdasarkan informasi dari data yang menjadi rujukan.

Perhitungan Manual

Pada slide di bawah, perhitungan manual dijelaskan yang diambil dari buku Data Mining karya Han and Kamber.

Beberapa kesalahan hitung terjadi ketika menghitung expected information dan entropi di tiap-tiap fitur/atribut. Untuk yang sedang mengambil kuliah ini ada baiknya berlatih soal-soal agar ketika ujian tidak terjadi salah hitung.

Perhitungan dengan Program

Berikutnya disertakan pula bagaimana mengimplementasikannya dengan Python, dalam hal ini menggunakan Google Colab. Saran untuk mahasiswa S1 dan D3 ada baiknya mengetik langsung kode (tanpa copas) agar bisa melatih skill/keterampilan. Sekaligus juga debug ketika ada error terjadi. Silahkan lihat video lengkapnya di youtube berikut ini. Semoga bermanfaat.

Menggunakan Algoritma Genetika dengan Python

Algoritma Genetika (GA) merupakan salah satu nature-inspired optimization yang meniru evolusi makhluk hidup. Gampangnya, generasi terkini merupakan generasi yang terbaik yang adaptif terhadap lingkungan. Prinsip seleksi, kawin silang, dan mutasi diterapkan ketika proses optimasi secara pemilihan acak (random) dilakukan. Karena adanya unsur pemilihan acak, GA masuk dalam kategori metaheuristik bersama particle swarm optimization (PSO), simulated annealing (SA), tabu search (TS), dan lain-lain.

Bagaimana algoritma tersebut bekerja dalam suatu bahasa pemrograman saat ini dengan mudah kita jumpai di internet, dari youtube, blog, hingga e-learning gratis. Saat ini modul-modul atau library dapat dijumpai, misalnya di Matlab. Nah, dalam postingan ini kita akan mencoba dengan bahasa pemrograman Python. Sebelumnya perlu sedikit pengertian antara pembuatan program dari awal dengan pemrograman lewat bantuan sebuah modul atau library.

Beberapa pengajar biasanya melarang mahasiswa untuk langsung menggunakan library karena memang peserta didik harus memahami konsep dasarnya terlebih dahulu. Untungnya beberapa situs menyediakan kode program jenis ini yang dishare misalnya ahmedfgad, datascienceplus, pythonheatlhcare, dan lain-lain. Saya dulu menggunakan Matlab, dan ketika beralih ke Python karena pernah dengan bahasa lain maka dengan mudah mengikuti kode dengan bahasa lainnya. Oiya, saat ini GA, PSO, TS, dan lain-lain lebih sering disebut metode dibanding dengan algoritma karena tingkat kompleks dan ciri khas akibat mengikuti prinsip tertentu (makhluk hidup, fisika, biologi, dan lain-lain).

Selain memahami prinsip dasar, dengan kode python GA yang murni berisi langkah-langkah dari seleksi, kawin silang dan mutasi, jika Anda mengambil riset doktoral terkadang perlu menggabungkan dengan metode-metode lain, misalnya riset saya dulu, mutlak harus memodifikasi seluruh kode yang ada, jadi agak sulit jika menggunakan library yang tinggal diimpor.

Nah, jika Anda sudah memahami, dan sekedar menggunakan atau membandingkan metode satu dengan lainnya, penggunaan library jauh lebih praktis. Misal Anda menemukan metode baru dan harus membandingkan dengan metode lain, maka metode lain pembanding itu dapat digunakan, bahkan karena karakternya yang dishare maka orang lain (terutama reviewer jurnal) yakin keabsahannya (bisa dicek sendiri). Untuk GA bisa menggunakan library dari situs-situs berikut antara lain geneticalgorithms, pygad, pydea, dan lain-lain. Sebagai ilustrasi silahkan melihat video saya berikut yang menggunakan Google Colab.

Menyisipkan Machine Learning Pada Aplikasi Web

Aplikasi web biasanya merupakan aplikasi bertipe front-end dimana antara user dengan machine saling berinteraksi. Sementara itu machine learning, bagian khusus dari data mining, kebanyakan bekerja sebagai back-end. Nah, agar machine learning terhubung dengan user, dibutuhkan user interface, salah satunya adalah aplikasi berbasis web. Python, sebagai bahasa yang memang dikhususkan untuk back-end menyediakan pula aplikasi front-end dalam bentuk web lewat beberapa framework-nya, salah satunya adalah Flask.

Menyisipkan Machine Learning

Bagaimana cara kerja Flask, silahkan lihat pos saya terdahulu. Beberapa library perlu dipersiapkan dari yang diperuntukan menjalankan machine learning (Pandas, NumPy, Keras, SKlearn, dan lain sebagainya) hingga yang memang khusus untuk Flask. Untuk studi kasus dipilih Support Vector Machine (SVM) untuk mengklasifikasi data penentuan beasiswa. Diperlukan tiga file program dengan satu file data. Tiga file tersebut antara lain satu file utama python dan dua file html untuk interface (main program untuk inputan dan result.html untuk keluaran). Berikut tampilan program utamanya.

Perhatikan letak training SVM setelah proses impor pustaka-pustaka yang dibutuhkan. Dua fungsi (template_test dan predict) dibutuhkan berturut-turut ketika program dieksekusi dan ketika tombol ditekan (via browser).

Testing

Untuk mengujinya, perlu memahami bagaimana konsep environment di python. Cara termudah adalah lewat Anaconda Navigator. Pastikan di environmen terpasang pustaka-pustaka yang dibutuhkan (bisa lewat PIP terminal ataupun lewat Anaconda). Buka environment yang tepat dengan menekan mouse di nama environmen tersebut dilanjutkan dengan mengklik kanan dan pilih “terminal” untuk membuka terminal yang mengarah ke environment tersebut. Environment ditunjukan dengan dalam kurung di terminal, misalnya kasus saya nama environmennya “tensorflow” (hanya nama saja).

Setelah masuk terminal arahkan folder ke lokasi program utama python-nya (berekstensi *.py). Untuk jelaskan silahkan buka video berikut ini. Sekian, semoga bermanfaat.

Untuk rekan-rekan mahasiswa yang sudah setia mengikuti perkuliahan (Univ. Islam 45, Univ. Nusa Putra, dan Univ. Bhayangkara Jakarta Raya) walaupun secara online di masa pandemic COVID-19, kami mengucapkan terima kasih sebesar-besarnya karena secara tidak langsung turut membantu terciptanya buku revisi “Data Mining” yang kini disertai bahasa Python yang Insya Allah sudah melewati revisi terakhir dan siap cetak.

Flask dan Jinja2 Untuk Aplikasi Machine Learning Berbasis Web

Mungkin ada pembaca yang sudah mahir metode-metode yang digunakan untuk machine learning, tapi kesulitan ketika membuat aplikasi yang digunakan oleh pengguna. Banyak pilihan yang mungkin, apakah berbasis desktop ataukah web. Pilihan berupa mejalankan lewat konsol tentu saja menyulitkan pengguna yang biasanya eksekutif pengambil keputusan. Untuk yang berbasis desktop (lihat pos yang lalu tentang tkinter) menyulitkan jika ingin digunakan bersama. Nah, penggunaan aplikasi berbasis web untuk machine learning menjadi satu-satunya pilihan yang baik. Dengan aplikasi web, aplikasi dapat digunakan oleh divisi lain. Pos ini merupakan penjelasan lebih lanjut dari post yang lalu dengan penambahan pada operasi aritmatika sederhana (penjumlahan).

Bahasa Pemrograman Front-End dan Back-End

Dua pilihan framework web berbasis python yang terkenal adalah “django” dan “flask”. Jika django diperuntukan untuk aplikasi besar (enterprise), flask cocok jika digunakan internal di perusahaan karena karakteristiknya yang microframework. Toh biasanya memang aplikasi machine learning tidak “diumbar” ke luar, melainkan hanya kepentingan internal saja. Biasanya memang machine learning bekerja secara back-end, sementara bahasa pemrograman lain seperti java, php, dan bahasa front-end lainnya diperbantukan. Tetapi ternyata dengan framework-framework web, python secara mengejutkan dapat digunakan sebagai front-end juga.

Mempersiapkan Pustaka (Library) Flask

Langkah penting pertama adalah menyiapkan pustaka untuk menjalankan Flask. Kita dapat menggunakan dua metode yaitu lewat konsole (dengan PIP) dan lewat Anaconda Navigator. Silahkan atur environment yang tepat agar tidak salah menggunakan environment.

Di sini saya menginstal Flask di environment “tensorflow” (hanya nama saja). Untuk yang konsol, gunakan “path” yang sesuai, atau bisa menggunakan aplikasi “virtualenv”. Atau untuk pemula seperti saya, gunakan saja Anaconda yang terintegrasi.

Format Folder Flask

Flask membutuhkan satu file python untuk menghidupkan server dan beberapa templet HTML untuk input dan outputnya. Misalnya untuk contoh kita menggunakan satu file python “web.py” untuk menghidupkan server dan mengatur komunikasi templet lainnya: “mainpage.html” dan “result.html”.

Gunakan beragam text editor untuk mengetik dan membaca program-program tersebut, misalnya notepad, sublimetext, IDLE, dan text editor lainnya. Pastikan letak file mengikuti standar di atas dimana HTML terletak dalam satu folder “templates”. Berikut contoh kode untuk menghidupkan server Flask.

Memang perlu usaha keras untuk rekan-rekan yang kurang memahami format HTML dan CSS. Silahkan pelajari sumber-sumber belajar HTML dan CSS tersebut. Atau bisa gunakan Bootstrap yang tersedia dengan cuma-cuma di internet.

Menghidupkan Server

Dengan environment yang sesuai, masuk ke mode konsol dan ketik: python <namafile.py> di folder yang tepat. Pastikan server hidup dengan indikasi adanya instruksi untuk mengakses http://127.0.0.1:<port>.

Untuk keluar bisa menggunakan “Ctrl+C”. Ada kejadian unik ketika saya mengutak-atik kode tetapi tidak bisa dijalankan karena server masih menyimpan yang lama (cache). Setelah mengganti port baru bisa.

Testing

Buka browser dan jalankan aplikasi. Pastikan dapat berjalan dengan sempurna. Silahkan untuk jelasnya buka video tutorial saya di Youtube berikut 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.

Simulated Annealing in Jupyter Notebook

Similar with particle swarm optimization, simulated annealing (SA) is a fast optimization method. It mimics the process of the cooling system in die casting. The cooling system in die casting should be slow to avoid the internal energy trapped in the cast that reduce the quality. The SA code can be found in the internet, e.g. the panda site.

SA use some exponential calculation, so we need to import “math” library in the beginning. Open your Jupyter Notebook with the proper environment. Use Anaconda Navigator to get the environment and open the terminal. After finding your working direktory, type “Jupyter Notebook” to open the IDE in your browser automatically. Copy and paste the SA code at the end of this post to show how the SA work. You can change the objective function according your case study.

Matplotlib library was used to create the performance chart. Best performance was at 8.1 after 258 iteration. Try the code below in your Jupyter Notebook or previous method, e.g. by console, IDLE, etc.

import time
import random
import math
import numpy as np
import matplotlib.pyplot as plt
#------------------------------------------------------------------------------
# Customization section:
initial_temperature = 100
cooling = 0.8  # cooling coefficient
number_variables = 2 
upper_bounds = [3, 3]   
lower_bounds = [-3, -3]  
computing_time = 1 # second(s)

def objective_function(X):
    x=X[0]
    y=X[1]
    value = 3*(1-x)**2*math.exp(-x**2 - (y+1)**2) - 10*(x/5 - x**3 - y**5)*math.exp(-x**2 - y**2) -1/3*math.exp(-(x+1)**2 - y**2)
    return value

#------------------------------------------------------------------------------
# Simulated Annealing Algorithm:
initial_solution=np.zeros((number_variables))
for v in range(number_variables):
    initial_solution[v] = random.uniform(lower_bounds[v],upper_bounds[v])

current_solution = initial_solution
best_solution = initial_solution
n = 1  # no of solutions accepted
best_fitness = objective_function(best_solution)
current_temperature = initial_temperature # current temperature
start = time.time()
no_attempts = 100 # number of attempts in each level of temperature
record_best_fitness =[]

for i in range(9999999):
    for j in range(no_attempts):

        for k in range(number_variables):
            current_solution[k] = best_solution[k] + 0.1*(random.uniform(lower_bounds[k],upper_bounds[k]))
            current_solution[k] = max(min(current_solution[k],upper_bounds[k]),lower_bounds[k])  # repair the solution respecting the bounds

        current_fitness = objective_function(current_solution)
        E = abs(current_fitness - best_fitness)
        if i == 0 and j == 0:
            EA = E

        if current_fitness < best_fitness:
            p = math.exp(-E/(EA*current_temperature))
            # make a decision to accept the worse solution or not
            if random.random()<p:
                accept = True # this worse solution is accepted
            else:
                accept = False # this worse solution is not accepted
        else:
            accept = True # accept better solution
        if accept==True:
            best_solution = current_solution # update the best solution
            best_fitness = objective_function(best_solution)
            n = n + 1 # count the solutions accepted
            EA = (EA *(n-1) + E)/n # update EA

    print('interation: {}, best_solution: {}, best_fitness: {}'.format(i, best_solution, best_fitness))
    record_best_fitness.append(best_fitness)
    # Cooling the temperature
    current_temperature = current_temperature*cooling
    # Stop by computing time
    end = time.time()
    if end-start >= computing_time:
        break
plt.plot(record_best_fitness)

Particle Swarm Optimization in Jupyter Notebook

Particle Swarm Optimization (PSO) has been widely used for solving optimization problems. This method has many advantages, in particular for the computational complexity. PSO mimics the flock of bird or the school of fish when searching for foods. It faster than genetic algorithms (GAs), so become the first choice when optimizing the complex problems, such as multi-objective optimization, optimization with many constraints, etc. Following is the particle velocity calculation and its new location.

pso

Many source codes can be found in the internet, for example this panda site. This beautiful code use object-oriented style with some classes. Some functions inside a class are easy to understand. This code can be copied and pasted in your jupyter notebook. As usual, use the Anaconda Navigator to choose the right environment. This code only uses a simple library: math, and matplotlib.

Choose your working directory to open the Jupyter Notebook by typing “juypyter notebook”. The Jupyter notebook then suddenly appear in your browser. Copy and paste the code to run the sample of PSO. This sample use two variables (X0 and X1). Use mm=-1 for minimizing problem and mm=1 for maximizing problem. A main class run two previous classes (Particle and PSO) to show the optimum result with a performance chart.

Here is the code:

import random
import math
import matplotlib.pyplot as plt
#------------------------------------------------------------------------------
# TO CUSTOMIZE THIS PSO CODE TO SOLVE UNCONSTRAINED OPTIMIZATION PROBLEMS, CHANGE THE PARAMETERS IN THIS SECTION ONLY:
# THE FOLLOWING PARAMETERS MUST BE CHANGED.
def objective_function(x):
    y = 3*(1-x[0])**2*math.exp(-x[0]**2 - (x[1]+1)**2) - 10*(x[0]/5 - x[0]**3 - x[1]**5)*math.exp(-x[0]**2 - x[1]**2) -1/3*math.exp(-(x[0]+1)**2 - x[1]**2);
    return y

bounds=[(-3,3),(-3,3)]   # upper and lower bounds of variables
nv = 2                   # number of variables
mm = -1                   # if minimization problem, mm = -1; if maximization problem, mm = 1

# THE FOLLOWING PARAMETERS ARE OPTIMAL.
particle_size=100         # number of particles
iterations=200           # max number of iterations
w=0.85                    # inertia constant
c1=1                    # cognative constant
c2=2                     # social constant
# END OF THE CUSTOMIZATION SECTION
#------------------------------------------------------------------------------    
class Particle:
    def __init__(self,bounds):
        self.particle_position=[]                     # particle position
        self.particle_velocity=[]                     # particle velocity
        self.local_best_particle_position=[]          # best position of the particle
        self.fitness_local_best_particle_position= initial_fitness  # initial objective function value of the best particle position
        self.fitness_particle_position=initial_fitness             # objective function value of the particle position

        for i in range(nv):
            self.particle_position.append(random.uniform(bounds[i][0],bounds[i][1])) # generate random initial position
            self.particle_velocity.append(random.uniform(-1,1)) # generate random initial velocity

    def evaluate(self,objective_function):
        self.fitness_particle_position=objective_function(self.particle_position)
        if mm == -1:
            if self.fitness_particle_position < self.fitness_local_best_particle_position:
                self.local_best_particle_position=self.particle_position                  # update the local best
                self.fitness_local_best_particle_position=self.fitness_particle_position  # update the fitness of the local best
        if mm == 1:
            if self.fitness_particle_position > self.fitness_local_best_particle_position:
                self.local_best_particle_position=self.particle_position                  # update the local best
                self.fitness_local_best_particle_position=self.fitness_particle_position  # update the fitness of the local best

    def update_velocity(self,global_best_particle_position):
        for i in range(nv):
            r1=random.random()
            r2=random.random()

            cognitive_velocity = c1*r1*(self.local_best_particle_position[i] - self.particle_position[i])
            social_velocity = c2*r2*(global_best_particle_position[i] - self.particle_position[i])
            self.particle_velocity[i] = w*self.particle_velocity[i]+ cognitive_velocity + social_velocity

    def update_position(self,bounds):
        for i in range(nv):
            self.particle_position[i]=self.particle_position[i]+self.particle_velocity[i]

            # check and repair to satisfy the upper bounds
            if self.particle_position[i]>bounds[i][1]:
                self.particle_position[i]=bounds[i][1]
            # check and repair to satisfy the lower bounds
            if self.particle_position[i] < bounds[i][0]:
                self.particle_position[i]=bounds[i][0]

class PSO():
    def __init__(self,objective_function,bounds,particle_size,iterations):

        fitness_global_best_particle_position=initial_fitness
        global_best_particle_position=[]

        swarm_particle=[]
        for i in range(particle_size):
            swarm_particle.append(Particle(bounds))
        A=[]

        for i in range(iterations):
            for j in range(particle_size):
                swarm_particle[j].evaluate(objective_function)

                if mm ==-1:
                    if swarm_particle[j].fitness_particle_position < fitness_global_best_particle_position:
                        global_best_particle_position = list(swarm_particle[j].particle_position)
                        fitness_global_best_particle_position = float(swarm_particle[j].fitness_particle_position)
                if mm ==1:
                    if swarm_particle[j].fitness_particle_position > fitness_global_best_particle_position:
                        global_best_particle_position = list(swarm_particle[j].particle_position)
                        fitness_global_best_particle_position = float(swarm_particle[j].fitness_particle_position)
            for j in range(particle_size):
                swarm_particle[j].update_velocity(global_best_particle_position)
                swarm_particle[j].update_position(bounds)

            A.append(fitness_global_best_particle_position) # record the best fitness

        print('Optimal solution:', global_best_particle_position)
        print('Objective function value:', fitness_global_best_particle_position)
        print('Evolutionary process of the objective function value:')
        plt.plot(A)
#------------------------------------------------------------------------------
if mm == -1:
    initial_fitness = float("inf") # for minimization problem
if mm == 1:
    initial_fitness = -float("inf") # for maximization problem
#------------------------------------------------------------------------------   
# Main PSO         
PSO(objective_function,bounds,particle_size,iterations)

Optimalisasi Multiobjektif

Biasanya dalam optimalisasi, fungsi yang akan dicari nilai optimalnya hanya berjumlah satu. Fungsi tersebut dikenal dengan nama fungsi objektif (objective function) atau beberapa peneliti lebih senang dengan istilah fungsi kriteria (criteria function). Tetapi di lapangan kebanyakan fungsi objektif lebih dari satu, sehingga perlu penanganan untuk mengoptimalkan fungsi-fungsi tersebut, yang dikenal dengan istilah optimalisasi multiobjective (multiobjective optimization).

Salah satu teknik yang sering dan mudah digunakan adalah dengan pembobotan, atau dikenal dengan istilah aggregating function. Besar bobot di tiap-tiap fungsi objektif perlu diriset terlebih dahulu, atau dengan menanyakan kepada para pakar di bidangnya. MIsalnya kita memiliki dua fungsi:

Coba gunakan Matlab untuk melihat grafik dua fungsi objektif tersebut. Tampak adanya kontradiksi. Di sinilah peran penanganan multiobjektif.


x=-10:0.1:10;
y1=x.^2+6;
plot(x,y1,'r')
grid on
hold
%Current plot held
y2=-(x.^2)+12;
plot(x,y2,'b')

Tampak kedua fungsi bertolak belakang. Di sini misalnya kita sudah memiliki bobot masing-masing untuk fungsi 1 dan 2 berturut-turut 0.7 dan 0.3. Maka untuk optimalisasi kita butuh satu fungsi baru, yang nantinya digunakan sebagai fungsi objektif pada algoritma optimasi yang dipilih. Tambahkan 2 kode baru lanjutan dari yang di atas.


yobj=0.7*y1+0.3*y2;
plot(x,yobj,'k')

Nah kita tinggal mengoptimalkan fobj yang berwarna hitam tersebut dengan metode yang Anda sukai, misalnya algoritma genetika. Ketik optimtool(‘ga’). Nah, di sini perlu membuat m-file yang berisi fungsi objektif. Ketik sembarang nama, misalnya “fungsi” di command window isi coding berikut:

Masukan nama fungsi tersebut diawali dengan @ di bagian “fitness function”. Di bagian “Plot Function” ceklis pada best fitness dan best individualnya agar lebih interaktif ketika Matlab memprosesnya. Tekan “Start” jika dirasa sudah siap. Oiya, jangan lupa “Number of Variables” diisi, tentu saja satu variabel yang terlibat “x”.

Perhatikan di bagian hasil, diperoleh titik 0.001 sebagai titik optimal dengan fitness 7.8. Sekian, semoga bisa menginspirasi.

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.

 

Training, Validating, Testing dan Corpus

Empat kata di atas, terutama tiga pertama merupakan istilah yang banyak disebut dalam literatur machine learning. Sementara yang keempat, Corpus, muncul belakangan ketika banyaknya pihak-pihak yang berkontribusi dengan membagikan file big data yang dimilikinya. Postingan kali ini sedikit menambah penjelasan mengenai penggunaan istilah-istilah di atas.

Training

Istilah ini merupakan pengkhususan dari arti sebenarnya: pelatihan/pembelajaran. Teringat ketika presentasi hasil penelitian di kampus yang dihadiri oleh beragam bidang ilmu. Salah satu peserta dari fakultas agama Islam memprotes manfaat dari training yang katanya tidak perlu karena menghambur-hamburkan dana. Peserta dari fakultas teknik, terutama jurusan informatika, hanya bisa tersenyum karena maklum istilah training di penelitian itu adalah proses melatih model agar diperoleh parameter yang tepat, bukan pelatihan berupa kursus, workshop, dan sejenisnya. Diperlukan data yang disertai dengan label dalam proses training ini. Banyak metode yang digunakan, biasanya backpropagation dengan turunannya gradient descent atau levenberg marquardt (LM). Data training ini dikenal dengan istilah training set.

Validating

Jika training membutuhkan data beserta label agar diperoleh parameter yang tepat, misalnya untuk jaringan syaraf tiruan (JST) berupa bobot dan bias, validating berisi data beserta label pula yang dimaksudkan untuk menguji hasil training apakah sudah akurat atau belum. Jika beruntung, hasil validasi akurat, biasanya di atas 75%. Jika belum harus di-training ulang. Data untuk validasi biasanya sebagian data training. Istilah data untuk validasi adalah development set, held-out set, atau validation set. Terkadang sebagian data training dipakai untuk validasi, kemudian secara bergantian yang tadinya buat training menjadi testing, yang dikenal dengan istilah cross validation.

Testing

Data testing atau dikenal dengan istilah testing set wajib dijalankan setelah validasi. Fungsinya membuktikan apakah model sudah sesuai dalam artian akurat di validasi dan akurat juga di kenyataannya. Data yang digunakan untuk testing merupakan data real yang tidak digunakan untuk training. Tentu saja tidak “fair” menggunakan data training untuk testing, ibarat ujian, soal yang diujikan diberitahu terlebih dahulu.

Corpus

Corpus merupakan kumpulan data spesifik. Jamaknya dikenal dengan nama Corpora. Data ini biasanya digunakan untuk testing yang berasal dari lembaga yang bersedia men-share untuk pembelajaran bersama, misalnya data aeronatika, video, suara, gambar, dan lain-lain. Jika Anda menginstal Python, disertakan juga Corpora secara opsional, karena memang ukurannya yang besar. Tentu saja Corpus ini dipergunakan biasanya untuk pengujian metode/algoritma apakah akurat atau tidak. Sementara untuk data spesifik tertentu, misal pengambilan keputusan kredit bank, pemberian beasiswa, penyetujuan proposal, perlu mencari data real yang ada jika tidak ada yang men-share karena memang data tersebut khusus/spesifik dimana tiap institusi/lokasi/objek penelitian berbeda-beda karakteristiknya. Yuk, yang punya data, bagi-bagi, untuk membantu riset teknologi informasi, terutama yang punya data bidang kesehatan.

Metaheuristic Optimization – Advanced

Metaheuristic pengertiannya telah sedikit diulas pada postingan yang lalu. Di sini sedikit diulas metode-metode yang dapat dikatakan advanced. Namun di sini advanced tidak serta-merta untuk tingkat lanjut melainkan sekedar memberitahukan metode-metode terbaru berdasarkan artikel-artikel jurnal yang sudah diterbitkan.

Metode heuristik terkini dapat diklasifikasikan berdasarkan aliran algoritma pencariannya, antara lain:

  • Mengambil inspirasi dari sifat-sifat alami (nature)
  • Mengambil inspirasi dari sifat-sifat fisika

Sifat-sifat yang diambil dari hukum alam telah banyak diteliti di metaheuristik, tetapi yang terkini dapat dirinci sebagai berikut:

  • PSO, bersasarkan sekolompok binatang dalam mencari makan
  • Dolphin     Echolocation (DE), berdasarkan teknik sonar yang dimiliki oleh lumba-lumba
  • Big Bang-Big Crunch (BB-BC), berdasarkan teori evolusi alam
  • Cuckoo Search (CS), berdasarkan sifat burung
  • Imperialist Competitive Algorithm (ICA)

Sementara itu ada algoritma-algoritma yang diambil dari sifat fisika, antara lain:

  • Charged System Search (CSS) dan Magnetic Charged System Search (MCSS), berdasarkan hukum Coulomb dan Newton
  • Colliding Bodies Optimization (CBO), berdasarkan tumbukan satu dimensi partikel
  • Ray Optimization (RO), berdasarkan hukum refraksi cahaya (snell)

Demikian kira-kira metode advanced metaheuristic yang bisa dibaca dari literatur-literatur baik jurnal maupun buku. Sekian informasinya, mudah-mudahan bisa dijelaskan lebih detil pada postingan berikutnya.

Metaheuristic Optimization

Optimalisasi (optimization) merupakan usaha menemukan hasil maksimal (maximization) atau minimal (minimization), tergantung dari kasus yang ingin dioptimalkan. Besar atau kecilnya hasil optimalisasi berdasarkan hitungan sebuah fungsi yang dikenal dengan nama fungsi objective (terkadang untuk bidang RS-GIS lebih disukai fungsi kriteria – criteria function). Secara algoritmik fungsi objektif dikenal dengan istilah fitness function. Selain itu ada batasan-batasan (constraint) tertentu dalam mencapai harga optimal dari objective tersebut.

Deterministik atau Stochastic

Untuk mencapai nilai minimal/maximal fungsi objective beragam metode sudah dikembangkan. Secara garis besar metode-metode yang ada dibagi menjadi deterministic dan stochastic. Deterministic merupakan metode lama dengan bantuan gradient, khusus untuk fungsi-fungsi kontinyu. Di sekolah dulu kita pernah menghitung nilai minimal sebuah fungsi dengan menurunkan dan menyamakannya dengan nol (dikenal dengan metode Newton). Metode stochastic muncul ketika yang akan dioptimalisasi bukan fungsi kontinyu, tidak konvergen, tidak bisa diturunkan dan aspek-aspek analitis lainnya. Beberapa literatur-literatur terkini menyebut metode stochastic dengan sebutan baru yang dikenal dengan nama metaheuristic. Pertama kali istilah ini diperkenalkan oleh Fred Glover di tahun 1986. Dalam proses pencarian, ada dua aspek yang ingin dikejar, diversifikasi (focus ke global optimal secepatnya, dikenal dengan istilah exploration), dan aspek lokalitas untuk mencari yang benar-benar optimal di suatu wilayah tertentu (dikenal dengan sebutan exploitation). Dua aspek tersebut (exploration dan exploitation) harus dikompromikan untuk menghasilkan metode heuristik yang tepat.

Metaheuristic

Metaheuristic merupakan gabungan kata Meta dan Heuristic. Heuristic artinya mencari jawaban dengan cara trial & error sementara meta berarti melampaui atau tingkat yang lebih dari. Jadi metaheuristic tidak hanya mencari jawaban dengan coba-coba saja melainkan dengan bantuan atau arahan dari faktor-faktor lain. Faktor-faktor itulah yang membuat banyaknya variasi dari metaheuristic ini. Algoritma-algoritma metaheuristic yang banyak dikenal dan diterapkan antara lain:

1. Simulated Annealing

Metode ini meniru proses pendinginan baja yang dicor. Fungsi yang digunakan adalah fungsi eksponensial:

dengan kB konstanta Boltzmann dan T adalah suhu (kelvin). E merupakan energi yang perubahannya setara dengan perubahan fungsi objektif:

Dengan gamma konstanta yang biasanya berharga 1 untuk penyederhanaan.

2. Genetic Algorithm

Algoritma genetika diperkenalkan oleh John Holland di tahun 60-an. Metode ini meniru sifat alami evolusi dimana yang adaptif adalah yang optimal. Setelah fungsi objektif ditentukan, maka serentetan algoritma bekerja mencari nilai optimal fungsi tersebut. Keunikan metode ini adalah mengkombinasikan antar nilai sementara yang diperoleh dengan kawin silang (crossover) dan mutasi. Awalnya nilai-nilai tersebut harus di-encode menjadi biner agar beberapa bitnya bisa disalingtukarkan dengan nilai lainnya dan juga untuk mutasi. Namun saat ini banyak dikembangkan metode tanpa mengkonversi bilangan tersebut menjadi biner. Pemilihannya pun (selection) berdasarkan bentuk peluang (roulette wheel) dimana nilai yang memiliki harga fitness besar akan memiliki peluang yang besar pula.

3. Differential Evolution

Differential Evolution (DE) merupakan metode pengembangan dari algoritma genetika yang diperkenalkan oleh R. Storn dan K. Price di tahun 96-97. Jika pada algoritma genetika kromosom dalam bentuk biner, DE menggunakan vektor sebagai kromosom.

Mutasi, crossover, dan selection sedikit lebih rumit dari algoritma genetika. Secara detail silahkan buka makalah aslinya.

4. Ant Colony Optimization

Metode ini meniru prinsip semut dalam usaha mencari makanan. Semut menggunakan senyawa kimia bernama pheromone ketika berjalan. Jalur yang banyak dilalui semut akan memiliki konsentrasi pheromone yang lebih banyak. Penurunan fungsi konsentarasi pheronome adalah berikut ini.

Jika ada jalur yang memiliki konsentrasi pheromone melebihi jalur yang lain maka jalur ini dikatakan favorit dan umpan balik positif berlaku di sini dan lama kelamaan berlaku kondisi “self-organized”.

5. Bee Algorithms

Sesuai dengan namanya, algoritma ini mengikuti pergerakan lebah dalam mencari sumber materi pembuatan madu. Mirip dengan semut, tawon juga mengeluarkan pheromone yang disertai dengan tarian “waggle dance”. Bee algorithm dikembangkan oleh Moritz and Southwick 1992, Craig A Tovey, Xin-She Yang, dan lain-lain.

Turunan algoritma ini cukup banyak, antara lain: honeybee algorithm, artificial bee colony, bee algorithm, virtual bee algorithm, dan honyebee mating algorithm. Banyak dikembangkan untuk optimasi posisi tertentu dalam suatu jaringan (misal server).

6. Particle Swarm Optimization

Particle Swarm Optimization (PSO) meniru pergerakan sekelompok binatang (ikan, burung, dll) dalam mencari makanan. Berbeda dengan algoritma genetika yang berganti individu (punah, baru, dan mutasi), PSO menjaga jumlah kelompok individu dan hanya perubahan posisi saja. Algoritma ini dikembangkan oleh Kennedy dan Eberhart (lihat pos yang lalu).

PSO memiliki dua nilai sebagai patokan pergerakan kerumunan: local optima dan global optima. Local optima merupakan nilai terbaik tiap individu di masa lampau (biasanya hanya sebelumnya saja) sementara global optima adalah nilai terbaik di kerumunan tersebut. Bobot antara keduanya menggambarkan karakter PSO apakah selfish atau sosialis. Selain itu langkah pergerakan menentukan karakter PSO apakah lebih tinggi daya jelajah atau lebih sempit tetapi berkualitas.

7. Tabu Search

Tabu search dikembangkan oleh Fred Glover di tahun 1970 (tapi baru dipublikasikan dalam bentuk buku di tahun 1997-an). Berbeda dengan PSO yang menggunakan data lampau satu atau dua iterasi sebelumnya, tabu search merekam seluruh data yang lampau. Manfaatnya adalah mengurangi jumlah komputasi karena data yang lama sudah ada dan tidak perlu dihitung ulang. Algoritma ini masih banyak peluang untuk dikembangkan dengan cara hybrid dengan metode lain.

8. Harmony Search

Ide dari algoritma ini adalah musik. Metode ini diperkenalkan oleh Z.W. Geem di tahun 2001. Prinsipnya adalah di tiap iterasi ada tiga jenis pencarian antara lain berdasarkan: daftar irama yang sudah terkenal dimainkan, mirim dengan yang ada dengan beberapa penekanan (pitching), dan merancang komposisi yang benar-benar baru. Pitch adjustment mengikuti pendekatan Markov Chain:

dengan b merupakan bandwidth yang mengontrol pitch adjustmant.

9. Firefly Algorithm

Metode ini dikembangkan oleh Xin-She Yang pada tahun 2008 dengan mendasari prinsip kerjanya dengan seekor kunang-kunang. Fakta unik kunang-kunang antara lain:

  • Kunang-kunang tidak memiliki jenis kelamin, interaksi dengan kunang-kunang lain tidak berdasarkan jenis kelamin.
  • Ketertarikan berdasarkan kecerahan dari cahaya. Kunang-kunang yang lebih bercahaya, lebih menarik kunang-kunang lain yang kurang bercahaya.

Kecerahan berdasarkan lanskap dari fungsi objektif-nya:

dengan beta merupakan tingkat kecerahan. Pergerakan kunang-kunang i mengikuti ketertarikan dengan kunang-kunang lain, j ditentukan dengan persamaan:

10 Advanced Method

Beberapa metode masuk kategori terkini dan sangat advanced, misalnya Cuckoo Search (CS) yang akan dibahas di lain waktu bersama-sama metode-metode terkini lainnya. Diyakini metode-metode terbaru tersebut lebih baik dari yang saat ini banyak digunakan (algoritma genetika, dan PSO). Sekian, semoga bisa membantu bagi yang tertarik dengan metode-metode optimasi metaheuristik.